CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/attachments/:attachmentId/accept");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/attachments/:attachmentId/accept")

require "http/client"

url = "{{baseUrl}}/attachments/:attachmentId/accept"

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

var client = new RestClient("{{baseUrl}}/attachments/:attachmentId/accept");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/attachments/:attachmentId/accept"

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

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/attachments/:attachmentId/accept"))
    .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}}/attachments/:attachmentId/accept")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/attachments/:attachmentId/accept")
  .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}}/attachments/:attachmentId/accept');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/attachments/:attachmentId/accept'
};

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

const url = '{{baseUrl}}/attachments/:attachmentId/accept';
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}}/attachments/:attachmentId/accept',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/attachments/:attachmentId/accept")
  .post(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/attachments/:attachmentId/accept');

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}}/attachments/:attachmentId/accept'
};

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

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

const url = '{{baseUrl}}/attachments/:attachmentId/accept';
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}}/attachments/:attachmentId/accept"]
                                                       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}}/attachments/:attachmentId/accept" in

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

 "{{baseUrl}}/attachments/:attachmentId/accept",
  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}}/attachments/:attachmentId/accept');

echo $response->getBody();

setUrl('{{baseUrl}}/attachments/:attachmentId/accept');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/attachments/:attachmentId/accept');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/attachments/:attachmentId/accept' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/attachments/:attachmentId/accept' -Method POST 

import http.client

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

conn.request("POST", "/baseUrl/attachments/:attachmentId/accept")

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

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

import requests

url = "{{baseUrl}}/attachments/:attachmentId/accept"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/attachments/:attachmentId/accept"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/attachments/:attachmentId/accept")

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/attachments/:attachmentId/accept') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http POST {{baseUrl}}/attachments/:attachmentId/accept

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/attachments/:attachmentId/accept

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/attachments/:attachmentId/accept")! 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}}/global-networks/:globalNetworkId/connect-peer-associations");

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  \"ConnectPeerId\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations" {:content-type :json
                                                                                                       :form-params {:ConnectPeerId ""
                                                                                                                     :DeviceId ""
                                                                                                                     :LinkId ""}})

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ConnectPeerId\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\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}}/global-networks/:globalNetworkId/connect-peer-associations"),
    Content = new StringContent("{\n  \"ConnectPeerId\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\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}}/global-networks/:globalNetworkId/connect-peer-associations");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ConnectPeerId\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations"

	payload := strings.NewReader("{\n  \"ConnectPeerId\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\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/global-networks/:globalNetworkId/connect-peer-associations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 59

{
  "ConnectPeerId": "",
  "DeviceId": "",
  "LinkId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ConnectPeerId\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ConnectPeerId\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\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  \"ConnectPeerId\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations")
  .header("content-type", "application/json")
  .body("{\n  \"ConnectPeerId\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ConnectPeerId: '',
  DeviceId: '',
  LinkId: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations',
  headers: {'content-type': 'application/json'},
  data: {ConnectPeerId: '', DeviceId: '', LinkId: ''}
};

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ConnectPeerId":"","DeviceId":"","LinkId":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ConnectPeerId": "",\n  "DeviceId": "",\n  "LinkId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ConnectPeerId\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations")
  .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/global-networks/:globalNetworkId/connect-peer-associations',
  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({ConnectPeerId: '', DeviceId: '', LinkId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations',
  headers: {'content-type': 'application/json'},
  body: {ConnectPeerId: '', DeviceId: '', LinkId: ''},
  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}}/global-networks/:globalNetworkId/connect-peer-associations');

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

req.type('json');
req.send({
  ConnectPeerId: '',
  DeviceId: '',
  LinkId: ''
});

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}}/global-networks/:globalNetworkId/connect-peer-associations',
  headers: {'content-type': 'application/json'},
  data: {ConnectPeerId: '', DeviceId: '', LinkId: ''}
};

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

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ConnectPeerId":"","DeviceId":"","LinkId":""}'
};

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 = @{ @"ConnectPeerId": @"",
                              @"DeviceId": @"",
                              @"LinkId": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations"]
                                                       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}}/global-networks/:globalNetworkId/connect-peer-associations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ConnectPeerId\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}" in

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

 "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations",
  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([
    'ConnectPeerId' => '',
    'DeviceId' => '',
    'LinkId' => ''
  ]),
  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}}/global-networks/:globalNetworkId/connect-peer-associations', [
  'body' => '{
  "ConnectPeerId": "",
  "DeviceId": "",
  "LinkId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ConnectPeerId' => '',
  'DeviceId' => '',
  'LinkId' => ''
]));

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

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

append(json_encode([
  'ConnectPeerId' => '',
  'DeviceId' => '',
  'LinkId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations');
$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}}/global-networks/:globalNetworkId/connect-peer-associations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ConnectPeerId": "",
  "DeviceId": "",
  "LinkId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ConnectPeerId": "",
  "DeviceId": "",
  "LinkId": ""
}'

import http.client

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

payload = "{\n  \"ConnectPeerId\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}"

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

conn.request("POST", "/baseUrl/global-networks/:globalNetworkId/connect-peer-associations", payload, headers)

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

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

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations"

payload = {
    "ConnectPeerId": "",
    "DeviceId": "",
    "LinkId": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations"

payload <- "{\n  \"ConnectPeerId\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\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}}/global-networks/:globalNetworkId/connect-peer-associations")

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  \"ConnectPeerId\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\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/global-networks/:globalNetworkId/connect-peer-associations') do |req|
  req.body = "{\n  \"ConnectPeerId\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations";

    let payload = json!({
        "ConnectPeerId": "",
        "DeviceId": "",
        "LinkId": ""
    });

    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 '{
  "ConnectPeerId": "",
  "DeviceId": "",
  "LinkId": ""
}' |  \
  http POST {{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ConnectPeerId": "",\n  "DeviceId": "",\n  "LinkId": ""\n}' \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations")! 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}}/global-networks/:globalNetworkId/customer-gateway-associations");

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  \"CustomerGatewayArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations" {:content-type :json
                                                                                                           :form-params {:CustomerGatewayArn ""
                                                                                                                         :DeviceId ""
                                                                                                                         :LinkId ""}})

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"CustomerGatewayArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\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}}/global-networks/:globalNetworkId/customer-gateway-associations"),
    Content = new StringContent("{\n  \"CustomerGatewayArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\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}}/global-networks/:globalNetworkId/customer-gateway-associations");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"CustomerGatewayArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations"

	payload := strings.NewReader("{\n  \"CustomerGatewayArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\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/global-networks/:globalNetworkId/customer-gateway-associations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 64

{
  "CustomerGatewayArn": "",
  "DeviceId": "",
  "LinkId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"CustomerGatewayArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CustomerGatewayArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\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  \"CustomerGatewayArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations")
  .header("content-type", "application/json")
  .body("{\n  \"CustomerGatewayArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  CustomerGatewayArn: '',
  DeviceId: '',
  LinkId: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations',
  headers: {'content-type': 'application/json'},
  data: {CustomerGatewayArn: '', DeviceId: '', LinkId: ''}
};

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"CustomerGatewayArn":"","DeviceId":"","LinkId":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CustomerGatewayArn": "",\n  "DeviceId": "",\n  "LinkId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CustomerGatewayArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations")
  .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/global-networks/:globalNetworkId/customer-gateway-associations',
  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({CustomerGatewayArn: '', DeviceId: '', LinkId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations',
  headers: {'content-type': 'application/json'},
  body: {CustomerGatewayArn: '', DeviceId: '', LinkId: ''},
  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}}/global-networks/:globalNetworkId/customer-gateway-associations');

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

req.type('json');
req.send({
  CustomerGatewayArn: '',
  DeviceId: '',
  LinkId: ''
});

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}}/global-networks/:globalNetworkId/customer-gateway-associations',
  headers: {'content-type': 'application/json'},
  data: {CustomerGatewayArn: '', DeviceId: '', LinkId: ''}
};

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

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"CustomerGatewayArn":"","DeviceId":"","LinkId":""}'
};

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 = @{ @"CustomerGatewayArn": @"",
                              @"DeviceId": @"",
                              @"LinkId": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations"]
                                                       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}}/global-networks/:globalNetworkId/customer-gateway-associations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"CustomerGatewayArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}" in

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

 "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations",
  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([
    'CustomerGatewayArn' => '',
    'DeviceId' => '',
    'LinkId' => ''
  ]),
  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}}/global-networks/:globalNetworkId/customer-gateway-associations', [
  'body' => '{
  "CustomerGatewayArn": "",
  "DeviceId": "",
  "LinkId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CustomerGatewayArn' => '',
  'DeviceId' => '',
  'LinkId' => ''
]));

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

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

append(json_encode([
  'CustomerGatewayArn' => '',
  'DeviceId' => '',
  'LinkId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations');
$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}}/global-networks/:globalNetworkId/customer-gateway-associations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CustomerGatewayArn": "",
  "DeviceId": "",
  "LinkId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CustomerGatewayArn": "",
  "DeviceId": "",
  "LinkId": ""
}'

import http.client

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

payload = "{\n  \"CustomerGatewayArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}"

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

conn.request("POST", "/baseUrl/global-networks/:globalNetworkId/customer-gateway-associations", payload, headers)

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

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

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations"

payload = {
    "CustomerGatewayArn": "",
    "DeviceId": "",
    "LinkId": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations"

payload <- "{\n  \"CustomerGatewayArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\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}}/global-networks/:globalNetworkId/customer-gateway-associations")

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  \"CustomerGatewayArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\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/global-networks/:globalNetworkId/customer-gateway-associations') do |req|
  req.body = "{\n  \"CustomerGatewayArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations";

    let payload = json!({
        "CustomerGatewayArn": "",
        "DeviceId": "",
        "LinkId": ""
    });

    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 '{
  "CustomerGatewayArn": "",
  "DeviceId": "",
  "LinkId": ""
}' |  \
  http POST {{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "CustomerGatewayArn": "",\n  "DeviceId": "",\n  "LinkId": ""\n}' \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations")! 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}}/global-networks/:globalNetworkId/link-associations");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/global-networks/:globalNetworkId/link-associations" {:content-type :json
                                                                                               :form-params {:DeviceId ""
                                                                                                             :LinkId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/link-associations"

	payload := strings.NewReader("{\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\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/global-networks/:globalNetworkId/link-associations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 36

{
  "DeviceId": "",
  "LinkId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/global-networks/:globalNetworkId/link-associations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-networks/:globalNetworkId/link-associations"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/link-associations")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/global-networks/:globalNetworkId/link-associations")
  .header("content-type", "application/json")
  .body("{\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  DeviceId: '',
  LinkId: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/global-networks/:globalNetworkId/link-associations');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/link-associations',
  headers: {'content-type': 'application/json'},
  data: {DeviceId: '', LinkId: ''}
};

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId/link-associations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DeviceId":"","LinkId":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/global-networks/:globalNetworkId/link-associations',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DeviceId": "",\n  "LinkId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/link-associations")
  .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/global-networks/:globalNetworkId/link-associations',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({DeviceId: '', LinkId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/link-associations',
  headers: {'content-type': 'application/json'},
  body: {DeviceId: '', LinkId: ''},
  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}}/global-networks/:globalNetworkId/link-associations');

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

req.type('json');
req.send({
  DeviceId: '',
  LinkId: ''
});

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}}/global-networks/:globalNetworkId/link-associations',
  headers: {'content-type': 'application/json'},
  data: {DeviceId: '', LinkId: ''}
};

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

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId/link-associations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DeviceId":"","LinkId":""}'
};

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

#import 

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/global-networks/:globalNetworkId/link-associations"]
                                                       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}}/global-networks/:globalNetworkId/link-associations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}" in

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

 "{{baseUrl}}/global-networks/:globalNetworkId/link-associations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'DeviceId' => '',
    'LinkId' => ''
  ]),
  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}}/global-networks/:globalNetworkId/link-associations', [
  'body' => '{
  "DeviceId": "",
  "LinkId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/link-associations');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'DeviceId' => '',
  'LinkId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/link-associations');
$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}}/global-networks/:globalNetworkId/link-associations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DeviceId": "",
  "LinkId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/link-associations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DeviceId": "",
  "LinkId": ""
}'

import http.client

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

payload = "{\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}"

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

conn.request("POST", "/baseUrl/global-networks/:globalNetworkId/link-associations", payload, headers)

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

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

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/link-associations"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/link-associations"

payload <- "{\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\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}}/global-networks/:globalNetworkId/link-associations")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\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/global-networks/:globalNetworkId/link-associations') do |req|
  req.body = "{\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/link-associations";

    let payload = json!({
        "DeviceId": "",
        "LinkId": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "DeviceId": "",
  "LinkId": ""
}' |  \
  http POST {{baseUrl}}/global-networks/:globalNetworkId/link-associations \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "DeviceId": "",\n  "LinkId": ""\n}' \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/link-associations

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/link-associations")! 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}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations");

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  \"TransitGatewayConnectPeerArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations" {:content-type :json
                                                                                                                       :form-params {:TransitGatewayConnectPeerArn ""
                                                                                                                                     :DeviceId ""
                                                                                                                                     :LinkId ""}})

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"TransitGatewayConnectPeerArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\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}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations"),
    Content = new StringContent("{\n  \"TransitGatewayConnectPeerArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\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}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TransitGatewayConnectPeerArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations"

	payload := strings.NewReader("{\n  \"TransitGatewayConnectPeerArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\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/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 74

{
  "TransitGatewayConnectPeerArn": "",
  "DeviceId": "",
  "LinkId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TransitGatewayConnectPeerArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TransitGatewayConnectPeerArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\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  \"TransitGatewayConnectPeerArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations")
  .header("content-type", "application/json")
  .body("{\n  \"TransitGatewayConnectPeerArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TransitGatewayConnectPeerArn: '',
  DeviceId: '',
  LinkId: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations',
  headers: {'content-type': 'application/json'},
  data: {TransitGatewayConnectPeerArn: '', DeviceId: '', LinkId: ''}
};

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"TransitGatewayConnectPeerArn":"","DeviceId":"","LinkId":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TransitGatewayConnectPeerArn": "",\n  "DeviceId": "",\n  "LinkId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TransitGatewayConnectPeerArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations")
  .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/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations',
  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({TransitGatewayConnectPeerArn: '', DeviceId: '', LinkId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations',
  headers: {'content-type': 'application/json'},
  body: {TransitGatewayConnectPeerArn: '', DeviceId: '', LinkId: ''},
  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}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations');

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

req.type('json');
req.send({
  TransitGatewayConnectPeerArn: '',
  DeviceId: '',
  LinkId: ''
});

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}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations',
  headers: {'content-type': 'application/json'},
  data: {TransitGatewayConnectPeerArn: '', DeviceId: '', LinkId: ''}
};

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

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"TransitGatewayConnectPeerArn":"","DeviceId":"","LinkId":""}'
};

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 = @{ @"TransitGatewayConnectPeerArn": @"",
                              @"DeviceId": @"",
                              @"LinkId": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations"]
                                                       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}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"TransitGatewayConnectPeerArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}" in

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

 "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations",
  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([
    'TransitGatewayConnectPeerArn' => '',
    'DeviceId' => '',
    'LinkId' => ''
  ]),
  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}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations', [
  'body' => '{
  "TransitGatewayConnectPeerArn": "",
  "DeviceId": "",
  "LinkId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TransitGatewayConnectPeerArn' => '',
  'DeviceId' => '',
  'LinkId' => ''
]));

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

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

append(json_encode([
  'TransitGatewayConnectPeerArn' => '',
  'DeviceId' => '',
  'LinkId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations');
$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}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TransitGatewayConnectPeerArn": "",
  "DeviceId": "",
  "LinkId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TransitGatewayConnectPeerArn": "",
  "DeviceId": "",
  "LinkId": ""
}'

import http.client

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

payload = "{\n  \"TransitGatewayConnectPeerArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}"

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

conn.request("POST", "/baseUrl/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations", payload, headers)

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

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

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations"

payload = {
    "TransitGatewayConnectPeerArn": "",
    "DeviceId": "",
    "LinkId": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations"

payload <- "{\n  \"TransitGatewayConnectPeerArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\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}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations")

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  \"TransitGatewayConnectPeerArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\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/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations') do |req|
  req.body = "{\n  \"TransitGatewayConnectPeerArn\": \"\",\n  \"DeviceId\": \"\",\n  \"LinkId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations";

    let payload = json!({
        "TransitGatewayConnectPeerArn": "",
        "DeviceId": "",
        "LinkId": ""
    });

    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 '{
  "TransitGatewayConnectPeerArn": "",
  "DeviceId": "",
  "LinkId": ""
}' |  \
  http POST {{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "TransitGatewayConnectPeerArn": "",\n  "DeviceId": "",\n  "LinkId": ""\n}' \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations")! 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}}/connect-attachments");

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  \"CoreNetworkId\": \"\",\n  \"EdgeLocation\": \"\",\n  \"TransportAttachmentId\": \"\",\n  \"Options\": {\n    \"Protocol\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/connect-attachments" {:content-type :json
                                                                :form-params {:CoreNetworkId ""
                                                                              :EdgeLocation ""
                                                                              :TransportAttachmentId ""
                                                                              :Options {:Protocol ""}
                                                                              :Tags [{:Key ""
                                                                                      :Value ""}]
                                                                              :ClientToken ""}})

require "http/client"

url = "{{baseUrl}}/connect-attachments"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"CoreNetworkId\": \"\",\n  \"EdgeLocation\": \"\",\n  \"TransportAttachmentId\": \"\",\n  \"Options\": {\n    \"Protocol\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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}}/connect-attachments"),
    Content = new StringContent("{\n  \"CoreNetworkId\": \"\",\n  \"EdgeLocation\": \"\",\n  \"TransportAttachmentId\": \"\",\n  \"Options\": {\n    \"Protocol\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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}}/connect-attachments");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"CoreNetworkId\": \"\",\n  \"EdgeLocation\": \"\",\n  \"TransportAttachmentId\": \"\",\n  \"Options\": {\n    \"Protocol\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/connect-attachments"

	payload := strings.NewReader("{\n  \"CoreNetworkId\": \"\",\n  \"EdgeLocation\": \"\",\n  \"TransportAttachmentId\": \"\",\n  \"Options\": {\n    \"Protocol\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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/connect-attachments HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 202

{
  "CoreNetworkId": "",
  "EdgeLocation": "",
  "TransportAttachmentId": "",
  "Options": {
    "Protocol": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/connect-attachments")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"CoreNetworkId\": \"\",\n  \"EdgeLocation\": \"\",\n  \"TransportAttachmentId\": \"\",\n  \"Options\": {\n    \"Protocol\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/connect-attachments"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CoreNetworkId\": \"\",\n  \"EdgeLocation\": \"\",\n  \"TransportAttachmentId\": \"\",\n  \"Options\": {\n    \"Protocol\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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  \"CoreNetworkId\": \"\",\n  \"EdgeLocation\": \"\",\n  \"TransportAttachmentId\": \"\",\n  \"Options\": {\n    \"Protocol\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/connect-attachments")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/connect-attachments")
  .header("content-type", "application/json")
  .body("{\n  \"CoreNetworkId\": \"\",\n  \"EdgeLocation\": \"\",\n  \"TransportAttachmentId\": \"\",\n  \"Options\": {\n    \"Protocol\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  CoreNetworkId: '',
  EdgeLocation: '',
  TransportAttachmentId: '',
  Options: {
    Protocol: ''
  },
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  ClientToken: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/connect-attachments',
  headers: {'content-type': 'application/json'},
  data: {
    CoreNetworkId: '',
    EdgeLocation: '',
    TransportAttachmentId: '',
    Options: {Protocol: ''},
    Tags: [{Key: '', Value: ''}],
    ClientToken: ''
  }
};

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

const url = '{{baseUrl}}/connect-attachments';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"CoreNetworkId":"","EdgeLocation":"","TransportAttachmentId":"","Options":{"Protocol":""},"Tags":[{"Key":"","Value":""}],"ClientToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/connect-attachments',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CoreNetworkId": "",\n  "EdgeLocation": "",\n  "TransportAttachmentId": "",\n  "Options": {\n    "Protocol": ""\n  },\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "ClientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CoreNetworkId\": \"\",\n  \"EdgeLocation\": \"\",\n  \"TransportAttachmentId\": \"\",\n  \"Options\": {\n    \"Protocol\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/connect-attachments")
  .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/connect-attachments',
  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({
  CoreNetworkId: '',
  EdgeLocation: '',
  TransportAttachmentId: '',
  Options: {Protocol: ''},
  Tags: [{Key: '', Value: ''}],
  ClientToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/connect-attachments',
  headers: {'content-type': 'application/json'},
  body: {
    CoreNetworkId: '',
    EdgeLocation: '',
    TransportAttachmentId: '',
    Options: {Protocol: ''},
    Tags: [{Key: '', Value: ''}],
    ClientToken: ''
  },
  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}}/connect-attachments');

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

req.type('json');
req.send({
  CoreNetworkId: '',
  EdgeLocation: '',
  TransportAttachmentId: '',
  Options: {
    Protocol: ''
  },
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  ClientToken: ''
});

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}}/connect-attachments',
  headers: {'content-type': 'application/json'},
  data: {
    CoreNetworkId: '',
    EdgeLocation: '',
    TransportAttachmentId: '',
    Options: {Protocol: ''},
    Tags: [{Key: '', Value: ''}],
    ClientToken: ''
  }
};

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

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

const url = '{{baseUrl}}/connect-attachments';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"CoreNetworkId":"","EdgeLocation":"","TransportAttachmentId":"","Options":{"Protocol":""},"Tags":[{"Key":"","Value":""}],"ClientToken":""}'
};

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 = @{ @"CoreNetworkId": @"",
                              @"EdgeLocation": @"",
                              @"TransportAttachmentId": @"",
                              @"Options": @{ @"Protocol": @"" },
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"ClientToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/connect-attachments"]
                                                       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}}/connect-attachments" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"CoreNetworkId\": \"\",\n  \"EdgeLocation\": \"\",\n  \"TransportAttachmentId\": \"\",\n  \"Options\": {\n    \"Protocol\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}" in

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

 "{{baseUrl}}/connect-attachments",
  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([
    'CoreNetworkId' => '',
    'EdgeLocation' => '',
    'TransportAttachmentId' => '',
    'Options' => [
        'Protocol' => ''
    ],
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'ClientToken' => ''
  ]),
  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}}/connect-attachments', [
  'body' => '{
  "CoreNetworkId": "",
  "EdgeLocation": "",
  "TransportAttachmentId": "",
  "Options": {
    "Protocol": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CoreNetworkId' => '',
  'EdgeLocation' => '',
  'TransportAttachmentId' => '',
  'Options' => [
    'Protocol' => ''
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'ClientToken' => ''
]));

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

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

append(json_encode([
  'CoreNetworkId' => '',
  'EdgeLocation' => '',
  'TransportAttachmentId' => '',
  'Options' => [
    'Protocol' => ''
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'ClientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/connect-attachments');
$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}}/connect-attachments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CoreNetworkId": "",
  "EdgeLocation": "",
  "TransportAttachmentId": "",
  "Options": {
    "Protocol": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/connect-attachments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CoreNetworkId": "",
  "EdgeLocation": "",
  "TransportAttachmentId": "",
  "Options": {
    "Protocol": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}'

import http.client

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

payload = "{\n  \"CoreNetworkId\": \"\",\n  \"EdgeLocation\": \"\",\n  \"TransportAttachmentId\": \"\",\n  \"Options\": {\n    \"Protocol\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/connect-attachments", payload, headers)

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

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

import requests

url = "{{baseUrl}}/connect-attachments"

payload = {
    "CoreNetworkId": "",
    "EdgeLocation": "",
    "TransportAttachmentId": "",
    "Options": { "Protocol": "" },
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "ClientToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/connect-attachments"

payload <- "{\n  \"CoreNetworkId\": \"\",\n  \"EdgeLocation\": \"\",\n  \"TransportAttachmentId\": \"\",\n  \"Options\": {\n    \"Protocol\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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}}/connect-attachments")

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  \"CoreNetworkId\": \"\",\n  \"EdgeLocation\": \"\",\n  \"TransportAttachmentId\": \"\",\n  \"Options\": {\n    \"Protocol\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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/connect-attachments') do |req|
  req.body = "{\n  \"CoreNetworkId\": \"\",\n  \"EdgeLocation\": \"\",\n  \"TransportAttachmentId\": \"\",\n  \"Options\": {\n    \"Protocol\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "CoreNetworkId": "",
        "EdgeLocation": "",
        "TransportAttachmentId": "",
        "Options": json!({"Protocol": ""}),
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "ClientToken": ""
    });

    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 '{
  "CoreNetworkId": "",
  "EdgeLocation": "",
  "TransportAttachmentId": "",
  "Options": {
    "Protocol": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}' |  \
  http POST {{baseUrl}}/connect-attachments \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "CoreNetworkId": "",\n  "EdgeLocation": "",\n  "TransportAttachmentId": "",\n  "Options": {\n    "Protocol": ""\n  },\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "ClientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/connect-attachments

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "CoreNetworkId": "",
  "EdgeLocation": "",
  "TransportAttachmentId": "",
  "Options": ["Protocol": ""],
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "ClientToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/connect-attachments")! 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}}/connect-peers");

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  \"ConnectAttachmentId\": \"\",\n  \"CoreNetworkAddress\": \"\",\n  \"PeerAddress\": \"\",\n  \"BgpOptions\": {\n    \"PeerAsn\": \"\"\n  },\n  \"InsideCidrBlocks\": [],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/connect-peers" {:content-type :json
                                                          :form-params {:ConnectAttachmentId ""
                                                                        :CoreNetworkAddress ""
                                                                        :PeerAddress ""
                                                                        :BgpOptions {:PeerAsn ""}
                                                                        :InsideCidrBlocks []
                                                                        :Tags [{:Key ""
                                                                                :Value ""}]
                                                                        :ClientToken ""}})

require "http/client"

url = "{{baseUrl}}/connect-peers"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ConnectAttachmentId\": \"\",\n  \"CoreNetworkAddress\": \"\",\n  \"PeerAddress\": \"\",\n  \"BgpOptions\": {\n    \"PeerAsn\": \"\"\n  },\n  \"InsideCidrBlocks\": [],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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}}/connect-peers"),
    Content = new StringContent("{\n  \"ConnectAttachmentId\": \"\",\n  \"CoreNetworkAddress\": \"\",\n  \"PeerAddress\": \"\",\n  \"BgpOptions\": {\n    \"PeerAsn\": \"\"\n  },\n  \"InsideCidrBlocks\": [],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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}}/connect-peers");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ConnectAttachmentId\": \"\",\n  \"CoreNetworkAddress\": \"\",\n  \"PeerAddress\": \"\",\n  \"BgpOptions\": {\n    \"PeerAsn\": \"\"\n  },\n  \"InsideCidrBlocks\": [],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/connect-peers"

	payload := strings.NewReader("{\n  \"ConnectAttachmentId\": \"\",\n  \"CoreNetworkAddress\": \"\",\n  \"PeerAddress\": \"\",\n  \"BgpOptions\": {\n    \"PeerAsn\": \"\"\n  },\n  \"InsideCidrBlocks\": [],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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/connect-peers HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 232

{
  "ConnectAttachmentId": "",
  "CoreNetworkAddress": "",
  "PeerAddress": "",
  "BgpOptions": {
    "PeerAsn": ""
  },
  "InsideCidrBlocks": [],
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/connect-peers")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ConnectAttachmentId\": \"\",\n  \"CoreNetworkAddress\": \"\",\n  \"PeerAddress\": \"\",\n  \"BgpOptions\": {\n    \"PeerAsn\": \"\"\n  },\n  \"InsideCidrBlocks\": [],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/connect-peers"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ConnectAttachmentId\": \"\",\n  \"CoreNetworkAddress\": \"\",\n  \"PeerAddress\": \"\",\n  \"BgpOptions\": {\n    \"PeerAsn\": \"\"\n  },\n  \"InsideCidrBlocks\": [],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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  \"ConnectAttachmentId\": \"\",\n  \"CoreNetworkAddress\": \"\",\n  \"PeerAddress\": \"\",\n  \"BgpOptions\": {\n    \"PeerAsn\": \"\"\n  },\n  \"InsideCidrBlocks\": [],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/connect-peers")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/connect-peers")
  .header("content-type", "application/json")
  .body("{\n  \"ConnectAttachmentId\": \"\",\n  \"CoreNetworkAddress\": \"\",\n  \"PeerAddress\": \"\",\n  \"BgpOptions\": {\n    \"PeerAsn\": \"\"\n  },\n  \"InsideCidrBlocks\": [],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ConnectAttachmentId: '',
  CoreNetworkAddress: '',
  PeerAddress: '',
  BgpOptions: {
    PeerAsn: ''
  },
  InsideCidrBlocks: [],
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  ClientToken: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/connect-peers',
  headers: {'content-type': 'application/json'},
  data: {
    ConnectAttachmentId: '',
    CoreNetworkAddress: '',
    PeerAddress: '',
    BgpOptions: {PeerAsn: ''},
    InsideCidrBlocks: [],
    Tags: [{Key: '', Value: ''}],
    ClientToken: ''
  }
};

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

const url = '{{baseUrl}}/connect-peers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ConnectAttachmentId":"","CoreNetworkAddress":"","PeerAddress":"","BgpOptions":{"PeerAsn":""},"InsideCidrBlocks":[],"Tags":[{"Key":"","Value":""}],"ClientToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/connect-peers',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ConnectAttachmentId": "",\n  "CoreNetworkAddress": "",\n  "PeerAddress": "",\n  "BgpOptions": {\n    "PeerAsn": ""\n  },\n  "InsideCidrBlocks": [],\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "ClientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ConnectAttachmentId\": \"\",\n  \"CoreNetworkAddress\": \"\",\n  \"PeerAddress\": \"\",\n  \"BgpOptions\": {\n    \"PeerAsn\": \"\"\n  },\n  \"InsideCidrBlocks\": [],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/connect-peers")
  .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/connect-peers',
  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({
  ConnectAttachmentId: '',
  CoreNetworkAddress: '',
  PeerAddress: '',
  BgpOptions: {PeerAsn: ''},
  InsideCidrBlocks: [],
  Tags: [{Key: '', Value: ''}],
  ClientToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/connect-peers',
  headers: {'content-type': 'application/json'},
  body: {
    ConnectAttachmentId: '',
    CoreNetworkAddress: '',
    PeerAddress: '',
    BgpOptions: {PeerAsn: ''},
    InsideCidrBlocks: [],
    Tags: [{Key: '', Value: ''}],
    ClientToken: ''
  },
  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}}/connect-peers');

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

req.type('json');
req.send({
  ConnectAttachmentId: '',
  CoreNetworkAddress: '',
  PeerAddress: '',
  BgpOptions: {
    PeerAsn: ''
  },
  InsideCidrBlocks: [],
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  ClientToken: ''
});

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}}/connect-peers',
  headers: {'content-type': 'application/json'},
  data: {
    ConnectAttachmentId: '',
    CoreNetworkAddress: '',
    PeerAddress: '',
    BgpOptions: {PeerAsn: ''},
    InsideCidrBlocks: [],
    Tags: [{Key: '', Value: ''}],
    ClientToken: ''
  }
};

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

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

const url = '{{baseUrl}}/connect-peers';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ConnectAttachmentId":"","CoreNetworkAddress":"","PeerAddress":"","BgpOptions":{"PeerAsn":""},"InsideCidrBlocks":[],"Tags":[{"Key":"","Value":""}],"ClientToken":""}'
};

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 = @{ @"ConnectAttachmentId": @"",
                              @"CoreNetworkAddress": @"",
                              @"PeerAddress": @"",
                              @"BgpOptions": @{ @"PeerAsn": @"" },
                              @"InsideCidrBlocks": @[  ],
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"ClientToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/connect-peers"]
                                                       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}}/connect-peers" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ConnectAttachmentId\": \"\",\n  \"CoreNetworkAddress\": \"\",\n  \"PeerAddress\": \"\",\n  \"BgpOptions\": {\n    \"PeerAsn\": \"\"\n  },\n  \"InsideCidrBlocks\": [],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}" in

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

 "{{baseUrl}}/connect-peers",
  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([
    'ConnectAttachmentId' => '',
    'CoreNetworkAddress' => '',
    'PeerAddress' => '',
    'BgpOptions' => [
        'PeerAsn' => ''
    ],
    'InsideCidrBlocks' => [
        
    ],
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'ClientToken' => ''
  ]),
  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}}/connect-peers', [
  'body' => '{
  "ConnectAttachmentId": "",
  "CoreNetworkAddress": "",
  "PeerAddress": "",
  "BgpOptions": {
    "PeerAsn": ""
  },
  "InsideCidrBlocks": [],
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ConnectAttachmentId' => '',
  'CoreNetworkAddress' => '',
  'PeerAddress' => '',
  'BgpOptions' => [
    'PeerAsn' => ''
  ],
  'InsideCidrBlocks' => [
    
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'ClientToken' => ''
]));

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

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

append(json_encode([
  'ConnectAttachmentId' => '',
  'CoreNetworkAddress' => '',
  'PeerAddress' => '',
  'BgpOptions' => [
    'PeerAsn' => ''
  ],
  'InsideCidrBlocks' => [
    
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'ClientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/connect-peers');
$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}}/connect-peers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ConnectAttachmentId": "",
  "CoreNetworkAddress": "",
  "PeerAddress": "",
  "BgpOptions": {
    "PeerAsn": ""
  },
  "InsideCidrBlocks": [],
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/connect-peers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ConnectAttachmentId": "",
  "CoreNetworkAddress": "",
  "PeerAddress": "",
  "BgpOptions": {
    "PeerAsn": ""
  },
  "InsideCidrBlocks": [],
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}'

import http.client

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

payload = "{\n  \"ConnectAttachmentId\": \"\",\n  \"CoreNetworkAddress\": \"\",\n  \"PeerAddress\": \"\",\n  \"BgpOptions\": {\n    \"PeerAsn\": \"\"\n  },\n  \"InsideCidrBlocks\": [],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/connect-peers", payload, headers)

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

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

import requests

url = "{{baseUrl}}/connect-peers"

payload = {
    "ConnectAttachmentId": "",
    "CoreNetworkAddress": "",
    "PeerAddress": "",
    "BgpOptions": { "PeerAsn": "" },
    "InsideCidrBlocks": [],
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "ClientToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/connect-peers"

payload <- "{\n  \"ConnectAttachmentId\": \"\",\n  \"CoreNetworkAddress\": \"\",\n  \"PeerAddress\": \"\",\n  \"BgpOptions\": {\n    \"PeerAsn\": \"\"\n  },\n  \"InsideCidrBlocks\": [],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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}}/connect-peers")

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  \"ConnectAttachmentId\": \"\",\n  \"CoreNetworkAddress\": \"\",\n  \"PeerAddress\": \"\",\n  \"BgpOptions\": {\n    \"PeerAsn\": \"\"\n  },\n  \"InsideCidrBlocks\": [],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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/connect-peers') do |req|
  req.body = "{\n  \"ConnectAttachmentId\": \"\",\n  \"CoreNetworkAddress\": \"\",\n  \"PeerAddress\": \"\",\n  \"BgpOptions\": {\n    \"PeerAsn\": \"\"\n  },\n  \"InsideCidrBlocks\": [],\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "ConnectAttachmentId": "",
        "CoreNetworkAddress": "",
        "PeerAddress": "",
        "BgpOptions": json!({"PeerAsn": ""}),
        "InsideCidrBlocks": (),
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "ClientToken": ""
    });

    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 '{
  "ConnectAttachmentId": "",
  "CoreNetworkAddress": "",
  "PeerAddress": "",
  "BgpOptions": {
    "PeerAsn": ""
  },
  "InsideCidrBlocks": [],
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}' |  \
  http POST {{baseUrl}}/connect-peers \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ConnectAttachmentId": "",\n  "CoreNetworkAddress": "",\n  "PeerAddress": "",\n  "BgpOptions": {\n    "PeerAsn": ""\n  },\n  "InsideCidrBlocks": [],\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "ClientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/connect-peers

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "ConnectAttachmentId": "",
  "CoreNetworkAddress": "",
  "PeerAddress": "",
  "BgpOptions": ["PeerAsn": ""],
  "InsideCidrBlocks": [],
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "ClientToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/connect-peers")! 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}}/global-networks/:globalNetworkId/connections");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"DeviceId\": \"\",\n  \"ConnectedDeviceId\": \"\",\n  \"LinkId\": \"\",\n  \"ConnectedLinkId\": \"\",\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/global-networks/:globalNetworkId/connections" {:content-type :json
                                                                                         :form-params {:DeviceId ""
                                                                                                       :ConnectedDeviceId ""
                                                                                                       :LinkId ""
                                                                                                       :ConnectedLinkId ""
                                                                                                       :Description ""
                                                                                                       :Tags [{:Key ""
                                                                                                               :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/connections"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"DeviceId\": \"\",\n  \"ConnectedDeviceId\": \"\",\n  \"LinkId\": \"\",\n  \"ConnectedLinkId\": \"\",\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/global-networks/:globalNetworkId/connections"),
    Content = new StringContent("{\n  \"DeviceId\": \"\",\n  \"ConnectedDeviceId\": \"\",\n  \"LinkId\": \"\",\n  \"ConnectedLinkId\": \"\",\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/global-networks/:globalNetworkId/connections");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DeviceId\": \"\",\n  \"ConnectedDeviceId\": \"\",\n  \"LinkId\": \"\",\n  \"ConnectedLinkId\": \"\",\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/connections"

	payload := strings.NewReader("{\n  \"DeviceId\": \"\",\n  \"ConnectedDeviceId\": \"\",\n  \"LinkId\": \"\",\n  \"ConnectedLinkId\": \"\",\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

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

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

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

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

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

}

POST /baseUrl/global-networks/:globalNetworkId/connections HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 173

{
  "DeviceId": "",
  "ConnectedDeviceId": "",
  "LinkId": "",
  "ConnectedLinkId": "",
  "Description": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/global-networks/:globalNetworkId/connections")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DeviceId\": \"\",\n  \"ConnectedDeviceId\": \"\",\n  \"LinkId\": \"\",\n  \"ConnectedLinkId\": \"\",\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-networks/:globalNetworkId/connections"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DeviceId\": \"\",\n  \"ConnectedDeviceId\": \"\",\n  \"LinkId\": \"\",\n  \"ConnectedLinkId\": \"\",\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"DeviceId\": \"\",\n  \"ConnectedDeviceId\": \"\",\n  \"LinkId\": \"\",\n  \"ConnectedLinkId\": \"\",\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/connections")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/global-networks/:globalNetworkId/connections")
  .header("content-type", "application/json")
  .body("{\n  \"DeviceId\": \"\",\n  \"ConnectedDeviceId\": \"\",\n  \"LinkId\": \"\",\n  \"ConnectedLinkId\": \"\",\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  DeviceId: '',
  ConnectedDeviceId: '',
  LinkId: '',
  ConnectedLinkId: '',
  Description: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/global-networks/:globalNetworkId/connections');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/connections',
  headers: {'content-type': 'application/json'},
  data: {
    DeviceId: '',
    ConnectedDeviceId: '',
    LinkId: '',
    ConnectedLinkId: '',
    Description: '',
    Tags: [{Key: '', Value: ''}]
  }
};

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId/connections';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DeviceId":"","ConnectedDeviceId":"","LinkId":"","ConnectedLinkId":"","Description":"","Tags":[{"Key":"","Value":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/global-networks/:globalNetworkId/connections',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DeviceId": "",\n  "ConnectedDeviceId": "",\n  "LinkId": "",\n  "ConnectedLinkId": "",\n  "Description": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DeviceId\": \"\",\n  \"ConnectedDeviceId\": \"\",\n  \"LinkId\": \"\",\n  \"ConnectedLinkId\": \"\",\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/connections")
  .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/global-networks/:globalNetworkId/connections',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({
  DeviceId: '',
  ConnectedDeviceId: '',
  LinkId: '',
  ConnectedLinkId: '',
  Description: '',
  Tags: [{Key: '', Value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/connections',
  headers: {'content-type': 'application/json'},
  body: {
    DeviceId: '',
    ConnectedDeviceId: '',
    LinkId: '',
    ConnectedLinkId: '',
    Description: '',
    Tags: [{Key: '', Value: ''}]
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/global-networks/:globalNetworkId/connections');

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

req.type('json');
req.send({
  DeviceId: '',
  ConnectedDeviceId: '',
  LinkId: '',
  ConnectedLinkId: '',
  Description: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/connections',
  headers: {'content-type': 'application/json'},
  data: {
    DeviceId: '',
    ConnectedDeviceId: '',
    LinkId: '',
    ConnectedLinkId: '',
    Description: '',
    Tags: [{Key: '', Value: ''}]
  }
};

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

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId/connections';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DeviceId":"","ConnectedDeviceId":"","LinkId":"","ConnectedLinkId":"","Description":"","Tags":[{"Key":"","Value":""}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"DeviceId": @"",
                              @"ConnectedDeviceId": @"",
                              @"LinkId": @"",
                              @"ConnectedLinkId": @"",
                              @"Description": @"",
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/global-networks/:globalNetworkId/connections"]
                                                       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}}/global-networks/:globalNetworkId/connections" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"DeviceId\": \"\",\n  \"ConnectedDeviceId\": \"\",\n  \"LinkId\": \"\",\n  \"ConnectedLinkId\": \"\",\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/global-networks/:globalNetworkId/connections",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'DeviceId' => '',
    'ConnectedDeviceId' => '',
    'LinkId' => '',
    'ConnectedLinkId' => '',
    'Description' => '',
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/global-networks/:globalNetworkId/connections', [
  'body' => '{
  "DeviceId": "",
  "ConnectedDeviceId": "",
  "LinkId": "",
  "ConnectedLinkId": "",
  "Description": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/connections');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DeviceId' => '',
  'ConnectedDeviceId' => '',
  'LinkId' => '',
  'ConnectedLinkId' => '',
  'Description' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'DeviceId' => '',
  'ConnectedDeviceId' => '',
  'LinkId' => '',
  'ConnectedLinkId' => '',
  'Description' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/connections');
$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}}/global-networks/:globalNetworkId/connections' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DeviceId": "",
  "ConnectedDeviceId": "",
  "LinkId": "",
  "ConnectedLinkId": "",
  "Description": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/connections' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DeviceId": "",
  "ConnectedDeviceId": "",
  "LinkId": "",
  "ConnectedLinkId": "",
  "Description": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"DeviceId\": \"\",\n  \"ConnectedDeviceId\": \"\",\n  \"LinkId\": \"\",\n  \"ConnectedLinkId\": \"\",\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/global-networks/:globalNetworkId/connections", payload, headers)

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

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

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/connections"

payload = {
    "DeviceId": "",
    "ConnectedDeviceId": "",
    "LinkId": "",
    "ConnectedLinkId": "",
    "Description": "",
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/connections"

payload <- "{\n  \"DeviceId\": \"\",\n  \"ConnectedDeviceId\": \"\",\n  \"LinkId\": \"\",\n  \"ConnectedLinkId\": \"\",\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks/:globalNetworkId/connections")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"DeviceId\": \"\",\n  \"ConnectedDeviceId\": \"\",\n  \"LinkId\": \"\",\n  \"ConnectedLinkId\": \"\",\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/global-networks/:globalNetworkId/connections') do |req|
  req.body = "{\n  \"DeviceId\": \"\",\n  \"ConnectedDeviceId\": \"\",\n  \"LinkId\": \"\",\n  \"ConnectedLinkId\": \"\",\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/connections";

    let payload = json!({
        "DeviceId": "",
        "ConnectedDeviceId": "",
        "LinkId": "",
        "ConnectedLinkId": "",
        "Description": "",
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

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

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

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

    dbg!(results);
}

echo '{
  "DeviceId": "",
  "ConnectedDeviceId": "",
  "LinkId": "",
  "ConnectedLinkId": "",
  "Description": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/global-networks/:globalNetworkId/connections \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "DeviceId": "",\n  "ConnectedDeviceId": "",\n  "LinkId": "",\n  "ConnectedLinkId": "",\n  "Description": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/connections

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "DeviceId": "",
  "ConnectedDeviceId": "",
  "LinkId": "",
  "ConnectedLinkId": "",
  "Description": "",
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/connections")! 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}}/core-networks");

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  \"GlobalNetworkId\": \"\",\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"PolicyDocument\": \"\",\n  \"ClientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/core-networks" {:content-type :json
                                                          :form-params {:GlobalNetworkId ""
                                                                        :Description ""
                                                                        :Tags [{:Key ""
                                                                                :Value ""}]
                                                                        :PolicyDocument ""
                                                                        :ClientToken ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/core-networks"

	payload := strings.NewReader("{\n  \"GlobalNetworkId\": \"\",\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"PolicyDocument\": \"\",\n  \"ClientToken\": \"\"\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/core-networks HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 157

{
  "GlobalNetworkId": "",
  "Description": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "PolicyDocument": "",
  "ClientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/core-networks")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GlobalNetworkId\": \"\",\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"PolicyDocument\": \"\",\n  \"ClientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/core-networks"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GlobalNetworkId\": \"\",\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"PolicyDocument\": \"\",\n  \"ClientToken\": \"\"\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  \"GlobalNetworkId\": \"\",\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"PolicyDocument\": \"\",\n  \"ClientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/core-networks")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/core-networks")
  .header("content-type", "application/json")
  .body("{\n  \"GlobalNetworkId\": \"\",\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"PolicyDocument\": \"\",\n  \"ClientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GlobalNetworkId: '',
  Description: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  PolicyDocument: '',
  ClientToken: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/core-networks',
  headers: {'content-type': 'application/json'},
  data: {
    GlobalNetworkId: '',
    Description: '',
    Tags: [{Key: '', Value: ''}],
    PolicyDocument: '',
    ClientToken: ''
  }
};

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

const url = '{{baseUrl}}/core-networks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"GlobalNetworkId":"","Description":"","Tags":[{"Key":"","Value":""}],"PolicyDocument":"","ClientToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/core-networks',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GlobalNetworkId": "",\n  "Description": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "PolicyDocument": "",\n  "ClientToken": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/core-networks',
  headers: {'content-type': 'application/json'},
  body: {
    GlobalNetworkId: '',
    Description: '',
    Tags: [{Key: '', Value: ''}],
    PolicyDocument: '',
    ClientToken: ''
  },
  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}}/core-networks');

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

req.type('json');
req.send({
  GlobalNetworkId: '',
  Description: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  PolicyDocument: '',
  ClientToken: ''
});

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}}/core-networks',
  headers: {'content-type': 'application/json'},
  data: {
    GlobalNetworkId: '',
    Description: '',
    Tags: [{Key: '', Value: ''}],
    PolicyDocument: '',
    ClientToken: ''
  }
};

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

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

const url = '{{baseUrl}}/core-networks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"GlobalNetworkId":"","Description":"","Tags":[{"Key":"","Value":""}],"PolicyDocument":"","ClientToken":""}'
};

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 = @{ @"GlobalNetworkId": @"",
                              @"Description": @"",
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"PolicyDocument": @"",
                              @"ClientToken": @"" };

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

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

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

 "{{baseUrl}}/core-networks",
  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([
    'GlobalNetworkId' => '',
    'Description' => '',
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'PolicyDocument' => '',
    'ClientToken' => ''
  ]),
  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}}/core-networks', [
  'body' => '{
  "GlobalNetworkId": "",
  "Description": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "PolicyDocument": "",
  "ClientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GlobalNetworkId' => '',
  'Description' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'PolicyDocument' => '',
  'ClientToken' => ''
]));

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

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

append(json_encode([
  'GlobalNetworkId' => '',
  'Description' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'PolicyDocument' => '',
  'ClientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/core-networks');
$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}}/core-networks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GlobalNetworkId": "",
  "Description": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "PolicyDocument": "",
  "ClientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/core-networks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GlobalNetworkId": "",
  "Description": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "PolicyDocument": "",
  "ClientToken": ""
}'

import http.client

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

payload = "{\n  \"GlobalNetworkId\": \"\",\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"PolicyDocument\": \"\",\n  \"ClientToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/core-networks", payload, headers)

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

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

import requests

url = "{{baseUrl}}/core-networks"

payload = {
    "GlobalNetworkId": "",
    "Description": "",
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "PolicyDocument": "",
    "ClientToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/core-networks"

payload <- "{\n  \"GlobalNetworkId\": \"\",\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"PolicyDocument\": \"\",\n  \"ClientToken\": \"\"\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}}/core-networks")

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  \"GlobalNetworkId\": \"\",\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"PolicyDocument\": \"\",\n  \"ClientToken\": \"\"\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/core-networks') do |req|
  req.body = "{\n  \"GlobalNetworkId\": \"\",\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"PolicyDocument\": \"\",\n  \"ClientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "GlobalNetworkId": "",
        "Description": "",
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "PolicyDocument": "",
        "ClientToken": ""
    });

    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 '{
  "GlobalNetworkId": "",
  "Description": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "PolicyDocument": "",
  "ClientToken": ""
}' |  \
  http POST {{baseUrl}}/core-networks \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "GlobalNetworkId": "",\n  "Description": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "PolicyDocument": "",\n  "ClientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/core-networks

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "GlobalNetworkId": "",
  "Description": "",
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "PolicyDocument": "",
  "ClientToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/core-networks")! 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}}/global-networks/:globalNetworkId/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  \"AWSLocation\": {\n    \"Zone\": \"\",\n    \"SubnetArn\": \"\"\n  },\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Vendor\": \"\",\n  \"Model\": \"\",\n  \"SerialNumber\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/global-networks/:globalNetworkId/devices" {:content-type :json
                                                                                     :form-params {:AWSLocation {:Zone ""
                                                                                                                 :SubnetArn ""}
                                                                                                   :Description ""
                                                                                                   :Type ""
                                                                                                   :Vendor ""
                                                                                                   :Model ""
                                                                                                   :SerialNumber ""
                                                                                                   :Location {:Address ""
                                                                                                              :Latitude ""
                                                                                                              :Longitude ""}
                                                                                                   :SiteId ""
                                                                                                   :Tags [{:Key ""
                                                                                                           :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/devices"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"AWSLocation\": {\n    \"Zone\": \"\",\n    \"SubnetArn\": \"\"\n  },\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Vendor\": \"\",\n  \"Model\": \"\",\n  \"SerialNumber\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/global-networks/:globalNetworkId/devices"),
    Content = new StringContent("{\n  \"AWSLocation\": {\n    \"Zone\": \"\",\n    \"SubnetArn\": \"\"\n  },\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Vendor\": \"\",\n  \"Model\": \"\",\n  \"SerialNumber\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/global-networks/:globalNetworkId/devices");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AWSLocation\": {\n    \"Zone\": \"\",\n    \"SubnetArn\": \"\"\n  },\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Vendor\": \"\",\n  \"Model\": \"\",\n  \"SerialNumber\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/devices"

	payload := strings.NewReader("{\n  \"AWSLocation\": {\n    \"Zone\": \"\",\n    \"SubnetArn\": \"\"\n  },\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Vendor\": \"\",\n  \"Model\": \"\",\n  \"SerialNumber\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

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

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

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

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

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

}

POST /baseUrl/global-networks/:globalNetworkId/devices HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 310

{
  "AWSLocation": {
    "Zone": "",
    "SubnetArn": ""
  },
  "Description": "",
  "Type": "",
  "Vendor": "",
  "Model": "",
  "SerialNumber": "",
  "Location": {
    "Address": "",
    "Latitude": "",
    "Longitude": ""
  },
  "SiteId": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/global-networks/:globalNetworkId/devices")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AWSLocation\": {\n    \"Zone\": \"\",\n    \"SubnetArn\": \"\"\n  },\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Vendor\": \"\",\n  \"Model\": \"\",\n  \"SerialNumber\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-networks/:globalNetworkId/devices"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AWSLocation\": {\n    \"Zone\": \"\",\n    \"SubnetArn\": \"\"\n  },\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Vendor\": \"\",\n  \"Model\": \"\",\n  \"SerialNumber\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"AWSLocation\": {\n    \"Zone\": \"\",\n    \"SubnetArn\": \"\"\n  },\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Vendor\": \"\",\n  \"Model\": \"\",\n  \"SerialNumber\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/devices")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/global-networks/:globalNetworkId/devices")
  .header("content-type", "application/json")
  .body("{\n  \"AWSLocation\": {\n    \"Zone\": \"\",\n    \"SubnetArn\": \"\"\n  },\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Vendor\": \"\",\n  \"Model\": \"\",\n  \"SerialNumber\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  AWSLocation: {
    Zone: '',
    SubnetArn: ''
  },
  Description: '',
  Type: '',
  Vendor: '',
  Model: '',
  SerialNumber: '',
  Location: {
    Address: '',
    Latitude: '',
    Longitude: ''
  },
  SiteId: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/devices',
  headers: {'content-type': 'application/json'},
  data: {
    AWSLocation: {Zone: '', SubnetArn: ''},
    Description: '',
    Type: '',
    Vendor: '',
    Model: '',
    SerialNumber: '',
    Location: {Address: '', Latitude: '', Longitude: ''},
    SiteId: '',
    Tags: [{Key: '', Value: ''}]
  }
};

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId/devices';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"AWSLocation":{"Zone":"","SubnetArn":""},"Description":"","Type":"","Vendor":"","Model":"","SerialNumber":"","Location":{"Address":"","Latitude":"","Longitude":""},"SiteId":"","Tags":[{"Key":"","Value":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/global-networks/:globalNetworkId/devices',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AWSLocation": {\n    "Zone": "",\n    "SubnetArn": ""\n  },\n  "Description": "",\n  "Type": "",\n  "Vendor": "",\n  "Model": "",\n  "SerialNumber": "",\n  "Location": {\n    "Address": "",\n    "Latitude": "",\n    "Longitude": ""\n  },\n  "SiteId": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AWSLocation\": {\n    \"Zone\": \"\",\n    \"SubnetArn\": \"\"\n  },\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Vendor\": \"\",\n  \"Model\": \"\",\n  \"SerialNumber\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/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/global-networks/:globalNetworkId/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({
  AWSLocation: {Zone: '', SubnetArn: ''},
  Description: '',
  Type: '',
  Vendor: '',
  Model: '',
  SerialNumber: '',
  Location: {Address: '', Latitude: '', Longitude: ''},
  SiteId: '',
  Tags: [{Key: '', Value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/devices',
  headers: {'content-type': 'application/json'},
  body: {
    AWSLocation: {Zone: '', SubnetArn: ''},
    Description: '',
    Type: '',
    Vendor: '',
    Model: '',
    SerialNumber: '',
    Location: {Address: '', Latitude: '', Longitude: ''},
    SiteId: '',
    Tags: [{Key: '', Value: ''}]
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/global-networks/:globalNetworkId/devices');

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

req.type('json');
req.send({
  AWSLocation: {
    Zone: '',
    SubnetArn: ''
  },
  Description: '',
  Type: '',
  Vendor: '',
  Model: '',
  SerialNumber: '',
  Location: {
    Address: '',
    Latitude: '',
    Longitude: ''
  },
  SiteId: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/devices',
  headers: {'content-type': 'application/json'},
  data: {
    AWSLocation: {Zone: '', SubnetArn: ''},
    Description: '',
    Type: '',
    Vendor: '',
    Model: '',
    SerialNumber: '',
    Location: {Address: '', Latitude: '', Longitude: ''},
    SiteId: '',
    Tags: [{Key: '', Value: ''}]
  }
};

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

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId/devices';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"AWSLocation":{"Zone":"","SubnetArn":""},"Description":"","Type":"","Vendor":"","Model":"","SerialNumber":"","Location":{"Address":"","Latitude":"","Longitude":""},"SiteId":"","Tags":[{"Key":"","Value":""}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AWSLocation": @{ @"Zone": @"", @"SubnetArn": @"" },
                              @"Description": @"",
                              @"Type": @"",
                              @"Vendor": @"",
                              @"Model": @"",
                              @"SerialNumber": @"",
                              @"Location": @{ @"Address": @"", @"Latitude": @"", @"Longitude": @"" },
                              @"SiteId": @"",
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/global-networks/:globalNetworkId/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}}/global-networks/:globalNetworkId/devices" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"AWSLocation\": {\n    \"Zone\": \"\",\n    \"SubnetArn\": \"\"\n  },\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Vendor\": \"\",\n  \"Model\": \"\",\n  \"SerialNumber\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/global-networks/:globalNetworkId/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([
    'AWSLocation' => [
        'Zone' => '',
        'SubnetArn' => ''
    ],
    'Description' => '',
    'Type' => '',
    'Vendor' => '',
    'Model' => '',
    'SerialNumber' => '',
    'Location' => [
        'Address' => '',
        'Latitude' => '',
        'Longitude' => ''
    ],
    'SiteId' => '',
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/global-networks/:globalNetworkId/devices', [
  'body' => '{
  "AWSLocation": {
    "Zone": "",
    "SubnetArn": ""
  },
  "Description": "",
  "Type": "",
  "Vendor": "",
  "Model": "",
  "SerialNumber": "",
  "Location": {
    "Address": "",
    "Latitude": "",
    "Longitude": ""
  },
  "SiteId": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/devices');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AWSLocation' => [
    'Zone' => '',
    'SubnetArn' => ''
  ],
  'Description' => '',
  'Type' => '',
  'Vendor' => '',
  'Model' => '',
  'SerialNumber' => '',
  'Location' => [
    'Address' => '',
    'Latitude' => '',
    'Longitude' => ''
  ],
  'SiteId' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'AWSLocation' => [
    'Zone' => '',
    'SubnetArn' => ''
  ],
  'Description' => '',
  'Type' => '',
  'Vendor' => '',
  'Model' => '',
  'SerialNumber' => '',
  'Location' => [
    'Address' => '',
    'Latitude' => '',
    'Longitude' => ''
  ],
  'SiteId' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/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}}/global-networks/:globalNetworkId/devices' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AWSLocation": {
    "Zone": "",
    "SubnetArn": ""
  },
  "Description": "",
  "Type": "",
  "Vendor": "",
  "Model": "",
  "SerialNumber": "",
  "Location": {
    "Address": "",
    "Latitude": "",
    "Longitude": ""
  },
  "SiteId": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/devices' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AWSLocation": {
    "Zone": "",
    "SubnetArn": ""
  },
  "Description": "",
  "Type": "",
  "Vendor": "",
  "Model": "",
  "SerialNumber": "",
  "Location": {
    "Address": "",
    "Latitude": "",
    "Longitude": ""
  },
  "SiteId": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"AWSLocation\": {\n    \"Zone\": \"\",\n    \"SubnetArn\": \"\"\n  },\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Vendor\": \"\",\n  \"Model\": \"\",\n  \"SerialNumber\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/global-networks/:globalNetworkId/devices", payload, headers)

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

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

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/devices"

payload = {
    "AWSLocation": {
        "Zone": "",
        "SubnetArn": ""
    },
    "Description": "",
    "Type": "",
    "Vendor": "",
    "Model": "",
    "SerialNumber": "",
    "Location": {
        "Address": "",
        "Latitude": "",
        "Longitude": ""
    },
    "SiteId": "",
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/devices"

payload <- "{\n  \"AWSLocation\": {\n    \"Zone\": \"\",\n    \"SubnetArn\": \"\"\n  },\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Vendor\": \"\",\n  \"Model\": \"\",\n  \"SerialNumber\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks/:globalNetworkId/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  \"AWSLocation\": {\n    \"Zone\": \"\",\n    \"SubnetArn\": \"\"\n  },\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Vendor\": \"\",\n  \"Model\": \"\",\n  \"SerialNumber\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/global-networks/:globalNetworkId/devices') do |req|
  req.body = "{\n  \"AWSLocation\": {\n    \"Zone\": \"\",\n    \"SubnetArn\": \"\"\n  },\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Vendor\": \"\",\n  \"Model\": \"\",\n  \"SerialNumber\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/devices";

    let payload = json!({
        "AWSLocation": json!({
            "Zone": "",
            "SubnetArn": ""
        }),
        "Description": "",
        "Type": "",
        "Vendor": "",
        "Model": "",
        "SerialNumber": "",
        "Location": json!({
            "Address": "",
            "Latitude": "",
            "Longitude": ""
        }),
        "SiteId": "",
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

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

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

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

    dbg!(results);
}

echo '{
  "AWSLocation": {
    "Zone": "",
    "SubnetArn": ""
  },
  "Description": "",
  "Type": "",
  "Vendor": "",
  "Model": "",
  "SerialNumber": "",
  "Location": {
    "Address": "",
    "Latitude": "",
    "Longitude": ""
  },
  "SiteId": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/global-networks/:globalNetworkId/devices \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "AWSLocation": {\n    "Zone": "",\n    "SubnetArn": ""\n  },\n  "Description": "",\n  "Type": "",\n  "Vendor": "",\n  "Model": "",\n  "SerialNumber": "",\n  "Location": {\n    "Address": "",\n    "Latitude": "",\n    "Longitude": ""\n  },\n  "SiteId": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/devices

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "AWSLocation": [
    "Zone": "",
    "SubnetArn": ""
  ],
  "Description": "",
  "Type": "",
  "Vendor": "",
  "Model": "",
  "SerialNumber": "",
  "Location": [
    "Address": "",
    "Latitude": "",
    "Longitude": ""
  ],
  "SiteId": "",
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/global-networks" {:content-type :json
                                                            :form-params {:Description ""
                                                                          :Tags [{:Key ""
                                                                                  :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/global-networks"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/global-networks"

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

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

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

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

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

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

}

POST /baseUrl/global-networks HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 87

{
  "Description": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

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

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/global-networks',
  headers: {'content-type': 'application/json'},
  data: {Description: '', Tags: [{Key: '', Value: ''}]}
};

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

const url = '{{baseUrl}}/global-networks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Description":"","Tags":[{"Key":"","Value":""}]}'
};

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

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

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/global-networks',
  headers: {'content-type': 'application/json'},
  body: {Description: '', Tags: [{Key: '', Value: ''}]},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/global-networks');

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

req.type('json');
req.send({
  Description: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/global-networks',
  headers: {'content-type': 'application/json'},
  data: {Description: '', Tags: [{Key: '', Value: ''}]}
};

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

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

const url = '{{baseUrl}}/global-networks';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Description":"","Tags":[{"Key":"","Value":""}]}'
};

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

#import 

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

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

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

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

 "{{baseUrl}}/global-networks",
  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([
    'Description' => '',
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/global-networks', [
  'body' => '{
  "Description": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/global-networks", payload, headers)

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

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

import requests

url = "{{baseUrl}}/global-networks"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks"

payload <- "{\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks")

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

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

require 'faraday'

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

response = conn.post('/baseUrl/global-networks') do |req|
  req.body = "{\n  \"Description\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Description": "",
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

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

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

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

    dbg!(results);
}

echo '{
  "Description": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/global-networks \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Description": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/global-networks

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks")! 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}}/global-networks/:globalNetworkId/links");

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  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Bandwidth\": {\n    \"UploadSpeed\": \"\",\n    \"DownloadSpeed\": \"\"\n  },\n  \"Provider\": \"\",\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/global-networks/:globalNetworkId/links" {:content-type :json
                                                                                   :form-params {:Description ""
                                                                                                 :Type ""
                                                                                                 :Bandwidth {:UploadSpeed ""
                                                                                                             :DownloadSpeed ""}
                                                                                                 :Provider ""
                                                                                                 :SiteId ""
                                                                                                 :Tags [{:Key ""
                                                                                                         :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/links"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Bandwidth\": {\n    \"UploadSpeed\": \"\",\n    \"DownloadSpeed\": \"\"\n  },\n  \"Provider\": \"\",\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/global-networks/:globalNetworkId/links"),
    Content = new StringContent("{\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Bandwidth\": {\n    \"UploadSpeed\": \"\",\n    \"DownloadSpeed\": \"\"\n  },\n  \"Provider\": \"\",\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/global-networks/:globalNetworkId/links");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Bandwidth\": {\n    \"UploadSpeed\": \"\",\n    \"DownloadSpeed\": \"\"\n  },\n  \"Provider\": \"\",\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/links"

	payload := strings.NewReader("{\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Bandwidth\": {\n    \"UploadSpeed\": \"\",\n    \"DownloadSpeed\": \"\"\n  },\n  \"Provider\": \"\",\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

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

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

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

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

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

}

POST /baseUrl/global-networks/:globalNetworkId/links HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 204

{
  "Description": "",
  "Type": "",
  "Bandwidth": {
    "UploadSpeed": "",
    "DownloadSpeed": ""
  },
  "Provider": "",
  "SiteId": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/global-networks/:globalNetworkId/links")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Bandwidth\": {\n    \"UploadSpeed\": \"\",\n    \"DownloadSpeed\": \"\"\n  },\n  \"Provider\": \"\",\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-networks/:globalNetworkId/links"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Bandwidth\": {\n    \"UploadSpeed\": \"\",\n    \"DownloadSpeed\": \"\"\n  },\n  \"Provider\": \"\",\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Bandwidth\": {\n    \"UploadSpeed\": \"\",\n    \"DownloadSpeed\": \"\"\n  },\n  \"Provider\": \"\",\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/links")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/global-networks/:globalNetworkId/links")
  .header("content-type", "application/json")
  .body("{\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Bandwidth\": {\n    \"UploadSpeed\": \"\",\n    \"DownloadSpeed\": \"\"\n  },\n  \"Provider\": \"\",\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  Description: '',
  Type: '',
  Bandwidth: {
    UploadSpeed: '',
    DownloadSpeed: ''
  },
  Provider: '',
  SiteId: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/global-networks/:globalNetworkId/links');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/links',
  headers: {'content-type': 'application/json'},
  data: {
    Description: '',
    Type: '',
    Bandwidth: {UploadSpeed: '', DownloadSpeed: ''},
    Provider: '',
    SiteId: '',
    Tags: [{Key: '', Value: ''}]
  }
};

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId/links';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Description":"","Type":"","Bandwidth":{"UploadSpeed":"","DownloadSpeed":""},"Provider":"","SiteId":"","Tags":[{"Key":"","Value":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/global-networks/:globalNetworkId/links',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Description": "",\n  "Type": "",\n  "Bandwidth": {\n    "UploadSpeed": "",\n    "DownloadSpeed": ""\n  },\n  "Provider": "",\n  "SiteId": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Bandwidth\": {\n    \"UploadSpeed\": \"\",\n    \"DownloadSpeed\": \"\"\n  },\n  \"Provider\": \"\",\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/links")
  .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/global-networks/:globalNetworkId/links',
  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({
  Description: '',
  Type: '',
  Bandwidth: {UploadSpeed: '', DownloadSpeed: ''},
  Provider: '',
  SiteId: '',
  Tags: [{Key: '', Value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/links',
  headers: {'content-type': 'application/json'},
  body: {
    Description: '',
    Type: '',
    Bandwidth: {UploadSpeed: '', DownloadSpeed: ''},
    Provider: '',
    SiteId: '',
    Tags: [{Key: '', Value: ''}]
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/global-networks/:globalNetworkId/links');

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

req.type('json');
req.send({
  Description: '',
  Type: '',
  Bandwidth: {
    UploadSpeed: '',
    DownloadSpeed: ''
  },
  Provider: '',
  SiteId: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/links',
  headers: {'content-type': 'application/json'},
  data: {
    Description: '',
    Type: '',
    Bandwidth: {UploadSpeed: '', DownloadSpeed: ''},
    Provider: '',
    SiteId: '',
    Tags: [{Key: '', Value: ''}]
  }
};

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

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId/links';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Description":"","Type":"","Bandwidth":{"UploadSpeed":"","DownloadSpeed":""},"Provider":"","SiteId":"","Tags":[{"Key":"","Value":""}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Description": @"",
                              @"Type": @"",
                              @"Bandwidth": @{ @"UploadSpeed": @"", @"DownloadSpeed": @"" },
                              @"Provider": @"",
                              @"SiteId": @"",
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/global-networks/:globalNetworkId/links"]
                                                       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}}/global-networks/:globalNetworkId/links" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Bandwidth\": {\n    \"UploadSpeed\": \"\",\n    \"DownloadSpeed\": \"\"\n  },\n  \"Provider\": \"\",\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/global-networks/:globalNetworkId/links",
  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([
    'Description' => '',
    'Type' => '',
    'Bandwidth' => [
        'UploadSpeed' => '',
        'DownloadSpeed' => ''
    ],
    'Provider' => '',
    'SiteId' => '',
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/global-networks/:globalNetworkId/links', [
  'body' => '{
  "Description": "",
  "Type": "",
  "Bandwidth": {
    "UploadSpeed": "",
    "DownloadSpeed": ""
  },
  "Provider": "",
  "SiteId": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/links');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Description' => '',
  'Type' => '',
  'Bandwidth' => [
    'UploadSpeed' => '',
    'DownloadSpeed' => ''
  ],
  'Provider' => '',
  'SiteId' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'Description' => '',
  'Type' => '',
  'Bandwidth' => [
    'UploadSpeed' => '',
    'DownloadSpeed' => ''
  ],
  'Provider' => '',
  'SiteId' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/links');
$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}}/global-networks/:globalNetworkId/links' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Description": "",
  "Type": "",
  "Bandwidth": {
    "UploadSpeed": "",
    "DownloadSpeed": ""
  },
  "Provider": "",
  "SiteId": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/links' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Description": "",
  "Type": "",
  "Bandwidth": {
    "UploadSpeed": "",
    "DownloadSpeed": ""
  },
  "Provider": "",
  "SiteId": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Bandwidth\": {\n    \"UploadSpeed\": \"\",\n    \"DownloadSpeed\": \"\"\n  },\n  \"Provider\": \"\",\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/global-networks/:globalNetworkId/links", payload, headers)

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

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

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/links"

payload = {
    "Description": "",
    "Type": "",
    "Bandwidth": {
        "UploadSpeed": "",
        "DownloadSpeed": ""
    },
    "Provider": "",
    "SiteId": "",
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/links"

payload <- "{\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Bandwidth\": {\n    \"UploadSpeed\": \"\",\n    \"DownloadSpeed\": \"\"\n  },\n  \"Provider\": \"\",\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks/:globalNetworkId/links")

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  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Bandwidth\": {\n    \"UploadSpeed\": \"\",\n    \"DownloadSpeed\": \"\"\n  },\n  \"Provider\": \"\",\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/global-networks/:globalNetworkId/links') do |req|
  req.body = "{\n  \"Description\": \"\",\n  \"Type\": \"\",\n  \"Bandwidth\": {\n    \"UploadSpeed\": \"\",\n    \"DownloadSpeed\": \"\"\n  },\n  \"Provider\": \"\",\n  \"SiteId\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/links";

    let payload = json!({
        "Description": "",
        "Type": "",
        "Bandwidth": json!({
            "UploadSpeed": "",
            "DownloadSpeed": ""
        }),
        "Provider": "",
        "SiteId": "",
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

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

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

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

    dbg!(results);
}

echo '{
  "Description": "",
  "Type": "",
  "Bandwidth": {
    "UploadSpeed": "",
    "DownloadSpeed": ""
  },
  "Provider": "",
  "SiteId": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/global-networks/:globalNetworkId/links \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Description": "",\n  "Type": "",\n  "Bandwidth": {\n    "UploadSpeed": "",\n    "DownloadSpeed": ""\n  },\n  "Provider": "",\n  "SiteId": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/links

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Description": "",
  "Type": "",
  "Bandwidth": [
    "UploadSpeed": "",
    "DownloadSpeed": ""
  ],
  "Provider": "",
  "SiteId": "",
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/links")! 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}}/global-networks/:globalNetworkId/sites");

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  \"Description\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/global-networks/:globalNetworkId/sites" {:content-type :json
                                                                                   :form-params {:Description ""
                                                                                                 :Location {:Address ""
                                                                                                            :Latitude ""
                                                                                                            :Longitude ""}
                                                                                                 :Tags [{:Key ""
                                                                                                         :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/sites"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Description\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/global-networks/:globalNetworkId/sites"),
    Content = new StringContent("{\n  \"Description\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/global-networks/:globalNetworkId/sites");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Description\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/sites"

	payload := strings.NewReader("{\n  \"Description\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

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

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

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

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

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

}

POST /baseUrl/global-networks/:globalNetworkId/sites HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 167

{
  "Description": "",
  "Location": {
    "Address": "",
    "Latitude": "",
    "Longitude": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/global-networks/:globalNetworkId/sites")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Description\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-networks/:globalNetworkId/sites"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Description\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Description\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/sites")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/global-networks/:globalNetworkId/sites")
  .header("content-type", "application/json")
  .body("{\n  \"Description\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  Description: '',
  Location: {
    Address: '',
    Latitude: '',
    Longitude: ''
  },
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/global-networks/:globalNetworkId/sites');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/sites',
  headers: {'content-type': 'application/json'},
  data: {
    Description: '',
    Location: {Address: '', Latitude: '', Longitude: ''},
    Tags: [{Key: '', Value: ''}]
  }
};

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId/sites';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Description":"","Location":{"Address":"","Latitude":"","Longitude":""},"Tags":[{"Key":"","Value":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/global-networks/:globalNetworkId/sites',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Description": "",\n  "Location": {\n    "Address": "",\n    "Latitude": "",\n    "Longitude": ""\n  },\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Description\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/sites")
  .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/global-networks/:globalNetworkId/sites',
  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({
  Description: '',
  Location: {Address: '', Latitude: '', Longitude: ''},
  Tags: [{Key: '', Value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/sites',
  headers: {'content-type': 'application/json'},
  body: {
    Description: '',
    Location: {Address: '', Latitude: '', Longitude: ''},
    Tags: [{Key: '', Value: ''}]
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/global-networks/:globalNetworkId/sites');

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

req.type('json');
req.send({
  Description: '',
  Location: {
    Address: '',
    Latitude: '',
    Longitude: ''
  },
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/sites',
  headers: {'content-type': 'application/json'},
  data: {
    Description: '',
    Location: {Address: '', Latitude: '', Longitude: ''},
    Tags: [{Key: '', Value: ''}]
  }
};

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

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId/sites';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Description":"","Location":{"Address":"","Latitude":"","Longitude":""},"Tags":[{"Key":"","Value":""}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Description": @"",
                              @"Location": @{ @"Address": @"", @"Latitude": @"", @"Longitude": @"" },
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/global-networks/:globalNetworkId/sites"]
                                                       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}}/global-networks/:globalNetworkId/sites" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Description\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/global-networks/:globalNetworkId/sites",
  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([
    'Description' => '',
    'Location' => [
        'Address' => '',
        'Latitude' => '',
        'Longitude' => ''
    ],
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/global-networks/:globalNetworkId/sites', [
  'body' => '{
  "Description": "",
  "Location": {
    "Address": "",
    "Latitude": "",
    "Longitude": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/sites');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Description' => '',
  'Location' => [
    'Address' => '',
    'Latitude' => '',
    'Longitude' => ''
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'Description' => '',
  'Location' => [
    'Address' => '',
    'Latitude' => '',
    'Longitude' => ''
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/sites');
$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}}/global-networks/:globalNetworkId/sites' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Description": "",
  "Location": {
    "Address": "",
    "Latitude": "",
    "Longitude": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/sites' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Description": "",
  "Location": {
    "Address": "",
    "Latitude": "",
    "Longitude": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"Description\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/global-networks/:globalNetworkId/sites", payload, headers)

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

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

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/sites"

payload = {
    "Description": "",
    "Location": {
        "Address": "",
        "Latitude": "",
        "Longitude": ""
    },
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/sites"

payload <- "{\n  \"Description\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks/:globalNetworkId/sites")

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  \"Description\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/global-networks/:globalNetworkId/sites') do |req|
  req.body = "{\n  \"Description\": \"\",\n  \"Location\": {\n    \"Address\": \"\",\n    \"Latitude\": \"\",\n    \"Longitude\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/sites";

    let payload = json!({
        "Description": "",
        "Location": json!({
            "Address": "",
            "Latitude": "",
            "Longitude": ""
        }),
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

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

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

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

    dbg!(results);
}

echo '{
  "Description": "",
  "Location": {
    "Address": "",
    "Latitude": "",
    "Longitude": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/global-networks/:globalNetworkId/sites \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Description": "",\n  "Location": {\n    "Address": "",\n    "Latitude": "",\n    "Longitude": ""\n  },\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/sites

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Description": "",
  "Location": [
    "Address": "",
    "Latitude": "",
    "Longitude": ""
  ],
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/sites")! 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}}/site-to-site-vpn-attachments");

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  \"CoreNetworkId\": \"\",\n  \"VpnConnectionArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/site-to-site-vpn-attachments" {:content-type :json
                                                                         :form-params {:CoreNetworkId ""
                                                                                       :VpnConnectionArn ""
                                                                                       :Tags [{:Key ""
                                                                                               :Value ""}]
                                                                                       :ClientToken ""}})

require "http/client"

url = "{{baseUrl}}/site-to-site-vpn-attachments"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"CoreNetworkId\": \"\",\n  \"VpnConnectionArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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}}/site-to-site-vpn-attachments"),
    Content = new StringContent("{\n  \"CoreNetworkId\": \"\",\n  \"VpnConnectionArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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}}/site-to-site-vpn-attachments");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"CoreNetworkId\": \"\",\n  \"VpnConnectionArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/site-to-site-vpn-attachments"

	payload := strings.NewReader("{\n  \"CoreNetworkId\": \"\",\n  \"VpnConnectionArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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/site-to-site-vpn-attachments HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 136

{
  "CoreNetworkId": "",
  "VpnConnectionArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/site-to-site-vpn-attachments")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"CoreNetworkId\": \"\",\n  \"VpnConnectionArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/site-to-site-vpn-attachments"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CoreNetworkId\": \"\",\n  \"VpnConnectionArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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  \"CoreNetworkId\": \"\",\n  \"VpnConnectionArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/site-to-site-vpn-attachments")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/site-to-site-vpn-attachments")
  .header("content-type", "application/json")
  .body("{\n  \"CoreNetworkId\": \"\",\n  \"VpnConnectionArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  CoreNetworkId: '',
  VpnConnectionArn: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  ClientToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/site-to-site-vpn-attachments');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/site-to-site-vpn-attachments',
  headers: {'content-type': 'application/json'},
  data: {
    CoreNetworkId: '',
    VpnConnectionArn: '',
    Tags: [{Key: '', Value: ''}],
    ClientToken: ''
  }
};

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

const url = '{{baseUrl}}/site-to-site-vpn-attachments';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"CoreNetworkId":"","VpnConnectionArn":"","Tags":[{"Key":"","Value":""}],"ClientToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/site-to-site-vpn-attachments',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CoreNetworkId": "",\n  "VpnConnectionArn": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "ClientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CoreNetworkId\": \"\",\n  \"VpnConnectionArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/site-to-site-vpn-attachments")
  .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/site-to-site-vpn-attachments',
  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({
  CoreNetworkId: '',
  VpnConnectionArn: '',
  Tags: [{Key: '', Value: ''}],
  ClientToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/site-to-site-vpn-attachments',
  headers: {'content-type': 'application/json'},
  body: {
    CoreNetworkId: '',
    VpnConnectionArn: '',
    Tags: [{Key: '', Value: ''}],
    ClientToken: ''
  },
  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}}/site-to-site-vpn-attachments');

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

req.type('json');
req.send({
  CoreNetworkId: '',
  VpnConnectionArn: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  ClientToken: ''
});

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}}/site-to-site-vpn-attachments',
  headers: {'content-type': 'application/json'},
  data: {
    CoreNetworkId: '',
    VpnConnectionArn: '',
    Tags: [{Key: '', Value: ''}],
    ClientToken: ''
  }
};

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

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

const url = '{{baseUrl}}/site-to-site-vpn-attachments';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"CoreNetworkId":"","VpnConnectionArn":"","Tags":[{"Key":"","Value":""}],"ClientToken":""}'
};

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 = @{ @"CoreNetworkId": @"",
                              @"VpnConnectionArn": @"",
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"ClientToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/site-to-site-vpn-attachments"]
                                                       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}}/site-to-site-vpn-attachments" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"CoreNetworkId\": \"\",\n  \"VpnConnectionArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}" in

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

 "{{baseUrl}}/site-to-site-vpn-attachments",
  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([
    'CoreNetworkId' => '',
    'VpnConnectionArn' => '',
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'ClientToken' => ''
  ]),
  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}}/site-to-site-vpn-attachments', [
  'body' => '{
  "CoreNetworkId": "",
  "VpnConnectionArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/site-to-site-vpn-attachments');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CoreNetworkId' => '',
  'VpnConnectionArn' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'ClientToken' => ''
]));

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

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

append(json_encode([
  'CoreNetworkId' => '',
  'VpnConnectionArn' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'ClientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/site-to-site-vpn-attachments');
$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}}/site-to-site-vpn-attachments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CoreNetworkId": "",
  "VpnConnectionArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/site-to-site-vpn-attachments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CoreNetworkId": "",
  "VpnConnectionArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}'

import http.client

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

payload = "{\n  \"CoreNetworkId\": \"\",\n  \"VpnConnectionArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/site-to-site-vpn-attachments", payload, headers)

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

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

import requests

url = "{{baseUrl}}/site-to-site-vpn-attachments"

payload = {
    "CoreNetworkId": "",
    "VpnConnectionArn": "",
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "ClientToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/site-to-site-vpn-attachments"

payload <- "{\n  \"CoreNetworkId\": \"\",\n  \"VpnConnectionArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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}}/site-to-site-vpn-attachments")

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  \"CoreNetworkId\": \"\",\n  \"VpnConnectionArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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/site-to-site-vpn-attachments') do |req|
  req.body = "{\n  \"CoreNetworkId\": \"\",\n  \"VpnConnectionArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/site-to-site-vpn-attachments";

    let payload = json!({
        "CoreNetworkId": "",
        "VpnConnectionArn": "",
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "ClientToken": ""
    });

    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 '{
  "CoreNetworkId": "",
  "VpnConnectionArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}' |  \
  http POST {{baseUrl}}/site-to-site-vpn-attachments \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "CoreNetworkId": "",\n  "VpnConnectionArn": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "ClientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/site-to-site-vpn-attachments

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "CoreNetworkId": "",
  "VpnConnectionArn": "",
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "ClientToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/site-to-site-vpn-attachments")! 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}}/transit-gateway-peerings");

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  \"CoreNetworkId\": \"\",\n  \"TransitGatewayArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/transit-gateway-peerings" {:content-type :json
                                                                     :form-params {:CoreNetworkId ""
                                                                                   :TransitGatewayArn ""
                                                                                   :Tags [{:Key ""
                                                                                           :Value ""}]
                                                                                   :ClientToken ""}})

require "http/client"

url = "{{baseUrl}}/transit-gateway-peerings"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"CoreNetworkId\": \"\",\n  \"TransitGatewayArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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}}/transit-gateway-peerings"),
    Content = new StringContent("{\n  \"CoreNetworkId\": \"\",\n  \"TransitGatewayArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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}}/transit-gateway-peerings");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"CoreNetworkId\": \"\",\n  \"TransitGatewayArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/transit-gateway-peerings"

	payload := strings.NewReader("{\n  \"CoreNetworkId\": \"\",\n  \"TransitGatewayArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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/transit-gateway-peerings HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 137

{
  "CoreNetworkId": "",
  "TransitGatewayArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/transit-gateway-peerings")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"CoreNetworkId\": \"\",\n  \"TransitGatewayArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/transit-gateway-peerings"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CoreNetworkId\": \"\",\n  \"TransitGatewayArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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  \"CoreNetworkId\": \"\",\n  \"TransitGatewayArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/transit-gateway-peerings")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/transit-gateway-peerings")
  .header("content-type", "application/json")
  .body("{\n  \"CoreNetworkId\": \"\",\n  \"TransitGatewayArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  CoreNetworkId: '',
  TransitGatewayArn: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  ClientToken: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/transit-gateway-peerings',
  headers: {'content-type': 'application/json'},
  data: {
    CoreNetworkId: '',
    TransitGatewayArn: '',
    Tags: [{Key: '', Value: ''}],
    ClientToken: ''
  }
};

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

const url = '{{baseUrl}}/transit-gateway-peerings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"CoreNetworkId":"","TransitGatewayArn":"","Tags":[{"Key":"","Value":""}],"ClientToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/transit-gateway-peerings',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CoreNetworkId": "",\n  "TransitGatewayArn": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "ClientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CoreNetworkId\": \"\",\n  \"TransitGatewayArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/transit-gateway-peerings")
  .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/transit-gateway-peerings',
  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({
  CoreNetworkId: '',
  TransitGatewayArn: '',
  Tags: [{Key: '', Value: ''}],
  ClientToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/transit-gateway-peerings',
  headers: {'content-type': 'application/json'},
  body: {
    CoreNetworkId: '',
    TransitGatewayArn: '',
    Tags: [{Key: '', Value: ''}],
    ClientToken: ''
  },
  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}}/transit-gateway-peerings');

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

req.type('json');
req.send({
  CoreNetworkId: '',
  TransitGatewayArn: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  ClientToken: ''
});

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}}/transit-gateway-peerings',
  headers: {'content-type': 'application/json'},
  data: {
    CoreNetworkId: '',
    TransitGatewayArn: '',
    Tags: [{Key: '', Value: ''}],
    ClientToken: ''
  }
};

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

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

const url = '{{baseUrl}}/transit-gateway-peerings';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"CoreNetworkId":"","TransitGatewayArn":"","Tags":[{"Key":"","Value":""}],"ClientToken":""}'
};

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 = @{ @"CoreNetworkId": @"",
                              @"TransitGatewayArn": @"",
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"ClientToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transit-gateway-peerings"]
                                                       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}}/transit-gateway-peerings" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"CoreNetworkId\": \"\",\n  \"TransitGatewayArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}" in

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

 "{{baseUrl}}/transit-gateway-peerings",
  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([
    'CoreNetworkId' => '',
    'TransitGatewayArn' => '',
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'ClientToken' => ''
  ]),
  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}}/transit-gateway-peerings', [
  'body' => '{
  "CoreNetworkId": "",
  "TransitGatewayArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/transit-gateway-peerings');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CoreNetworkId' => '',
  'TransitGatewayArn' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'ClientToken' => ''
]));

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

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

append(json_encode([
  'CoreNetworkId' => '',
  'TransitGatewayArn' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'ClientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/transit-gateway-peerings');
$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}}/transit-gateway-peerings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CoreNetworkId": "",
  "TransitGatewayArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/transit-gateway-peerings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CoreNetworkId": "",
  "TransitGatewayArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}'

import http.client

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

payload = "{\n  \"CoreNetworkId\": \"\",\n  \"TransitGatewayArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/transit-gateway-peerings", payload, headers)

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

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

import requests

url = "{{baseUrl}}/transit-gateway-peerings"

payload = {
    "CoreNetworkId": "",
    "TransitGatewayArn": "",
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "ClientToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/transit-gateway-peerings"

payload <- "{\n  \"CoreNetworkId\": \"\",\n  \"TransitGatewayArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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}}/transit-gateway-peerings")

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  \"CoreNetworkId\": \"\",\n  \"TransitGatewayArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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/transit-gateway-peerings') do |req|
  req.body = "{\n  \"CoreNetworkId\": \"\",\n  \"TransitGatewayArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "CoreNetworkId": "",
        "TransitGatewayArn": "",
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "ClientToken": ""
    });

    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 '{
  "CoreNetworkId": "",
  "TransitGatewayArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}' |  \
  http POST {{baseUrl}}/transit-gateway-peerings \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "CoreNetworkId": "",\n  "TransitGatewayArn": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "ClientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/transit-gateway-peerings

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "CoreNetworkId": "",
  "TransitGatewayArn": "",
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "ClientToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transit-gateway-peerings")! 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}}/transit-gateway-route-table-attachments");

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  \"PeeringId\": \"\",\n  \"TransitGatewayRouteTableArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/transit-gateway-route-table-attachments" {:content-type :json
                                                                                    :form-params {:PeeringId ""
                                                                                                  :TransitGatewayRouteTableArn ""
                                                                                                  :Tags [{:Key ""
                                                                                                          :Value ""}]
                                                                                                  :ClientToken ""}})

require "http/client"

url = "{{baseUrl}}/transit-gateway-route-table-attachments"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"PeeringId\": \"\",\n  \"TransitGatewayRouteTableArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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}}/transit-gateway-route-table-attachments"),
    Content = new StringContent("{\n  \"PeeringId\": \"\",\n  \"TransitGatewayRouteTableArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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}}/transit-gateway-route-table-attachments");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"PeeringId\": \"\",\n  \"TransitGatewayRouteTableArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/transit-gateway-route-table-attachments"

	payload := strings.NewReader("{\n  \"PeeringId\": \"\",\n  \"TransitGatewayRouteTableArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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/transit-gateway-route-table-attachments HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 143

{
  "PeeringId": "",
  "TransitGatewayRouteTableArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/transit-gateway-route-table-attachments")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"PeeringId\": \"\",\n  \"TransitGatewayRouteTableArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/transit-gateway-route-table-attachments"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"PeeringId\": \"\",\n  \"TransitGatewayRouteTableArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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  \"PeeringId\": \"\",\n  \"TransitGatewayRouteTableArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/transit-gateway-route-table-attachments")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/transit-gateway-route-table-attachments")
  .header("content-type", "application/json")
  .body("{\n  \"PeeringId\": \"\",\n  \"TransitGatewayRouteTableArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  PeeringId: '',
  TransitGatewayRouteTableArn: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  ClientToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/transit-gateway-route-table-attachments');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/transit-gateway-route-table-attachments',
  headers: {'content-type': 'application/json'},
  data: {
    PeeringId: '',
    TransitGatewayRouteTableArn: '',
    Tags: [{Key: '', Value: ''}],
    ClientToken: ''
  }
};

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

const url = '{{baseUrl}}/transit-gateway-route-table-attachments';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"PeeringId":"","TransitGatewayRouteTableArn":"","Tags":[{"Key":"","Value":""}],"ClientToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/transit-gateway-route-table-attachments',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "PeeringId": "",\n  "TransitGatewayRouteTableArn": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "ClientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"PeeringId\": \"\",\n  \"TransitGatewayRouteTableArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/transit-gateway-route-table-attachments")
  .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/transit-gateway-route-table-attachments',
  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({
  PeeringId: '',
  TransitGatewayRouteTableArn: '',
  Tags: [{Key: '', Value: ''}],
  ClientToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/transit-gateway-route-table-attachments',
  headers: {'content-type': 'application/json'},
  body: {
    PeeringId: '',
    TransitGatewayRouteTableArn: '',
    Tags: [{Key: '', Value: ''}],
    ClientToken: ''
  },
  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}}/transit-gateway-route-table-attachments');

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

req.type('json');
req.send({
  PeeringId: '',
  TransitGatewayRouteTableArn: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  ClientToken: ''
});

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}}/transit-gateway-route-table-attachments',
  headers: {'content-type': 'application/json'},
  data: {
    PeeringId: '',
    TransitGatewayRouteTableArn: '',
    Tags: [{Key: '', Value: ''}],
    ClientToken: ''
  }
};

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

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

const url = '{{baseUrl}}/transit-gateway-route-table-attachments';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"PeeringId":"","TransitGatewayRouteTableArn":"","Tags":[{"Key":"","Value":""}],"ClientToken":""}'
};

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 = @{ @"PeeringId": @"",
                              @"TransitGatewayRouteTableArn": @"",
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"ClientToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/transit-gateway-route-table-attachments"]
                                                       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}}/transit-gateway-route-table-attachments" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"PeeringId\": \"\",\n  \"TransitGatewayRouteTableArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}" in

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

 "{{baseUrl}}/transit-gateway-route-table-attachments",
  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([
    'PeeringId' => '',
    'TransitGatewayRouteTableArn' => '',
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'ClientToken' => ''
  ]),
  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}}/transit-gateway-route-table-attachments', [
  'body' => '{
  "PeeringId": "",
  "TransitGatewayRouteTableArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/transit-gateway-route-table-attachments');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'PeeringId' => '',
  'TransitGatewayRouteTableArn' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'ClientToken' => ''
]));

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

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

append(json_encode([
  'PeeringId' => '',
  'TransitGatewayRouteTableArn' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'ClientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/transit-gateway-route-table-attachments');
$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}}/transit-gateway-route-table-attachments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PeeringId": "",
  "TransitGatewayRouteTableArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/transit-gateway-route-table-attachments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PeeringId": "",
  "TransitGatewayRouteTableArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}'

import http.client

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

payload = "{\n  \"PeeringId\": \"\",\n  \"TransitGatewayRouteTableArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/transit-gateway-route-table-attachments", payload, headers)

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

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

import requests

url = "{{baseUrl}}/transit-gateway-route-table-attachments"

payload = {
    "PeeringId": "",
    "TransitGatewayRouteTableArn": "",
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "ClientToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/transit-gateway-route-table-attachments"

payload <- "{\n  \"PeeringId\": \"\",\n  \"TransitGatewayRouteTableArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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}}/transit-gateway-route-table-attachments")

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  \"PeeringId\": \"\",\n  \"TransitGatewayRouteTableArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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/transit-gateway-route-table-attachments') do |req|
  req.body = "{\n  \"PeeringId\": \"\",\n  \"TransitGatewayRouteTableArn\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/transit-gateway-route-table-attachments";

    let payload = json!({
        "PeeringId": "",
        "TransitGatewayRouteTableArn": "",
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "ClientToken": ""
    });

    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 '{
  "PeeringId": "",
  "TransitGatewayRouteTableArn": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}' |  \
  http POST {{baseUrl}}/transit-gateway-route-table-attachments \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "PeeringId": "",\n  "TransitGatewayRouteTableArn": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "ClientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/transit-gateway-route-table-attachments

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "PeeringId": "",
  "TransitGatewayRouteTableArn": "",
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "ClientToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/transit-gateway-route-table-attachments")! 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}}/vpc-attachments");

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  \"CoreNetworkId\": \"\",\n  \"VpcArn\": \"\",\n  \"SubnetArns\": [],\n  \"Options\": {\n    \"Ipv6Support\": \"\",\n    \"ApplianceModeSupport\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/vpc-attachments" {:content-type :json
                                                            :form-params {:CoreNetworkId ""
                                                                          :VpcArn ""
                                                                          :SubnetArns []
                                                                          :Options {:Ipv6Support ""
                                                                                    :ApplianceModeSupport ""}
                                                                          :Tags [{:Key ""
                                                                                  :Value ""}]
                                                                          :ClientToken ""}})

require "http/client"

url = "{{baseUrl}}/vpc-attachments"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"CoreNetworkId\": \"\",\n  \"VpcArn\": \"\",\n  \"SubnetArns\": [],\n  \"Options\": {\n    \"Ipv6Support\": \"\",\n    \"ApplianceModeSupport\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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}}/vpc-attachments"),
    Content = new StringContent("{\n  \"CoreNetworkId\": \"\",\n  \"VpcArn\": \"\",\n  \"SubnetArns\": [],\n  \"Options\": {\n    \"Ipv6Support\": \"\",\n    \"ApplianceModeSupport\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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}}/vpc-attachments");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"CoreNetworkId\": \"\",\n  \"VpcArn\": \"\",\n  \"SubnetArns\": [],\n  \"Options\": {\n    \"Ipv6Support\": \"\",\n    \"ApplianceModeSupport\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/vpc-attachments"

	payload := strings.NewReader("{\n  \"CoreNetworkId\": \"\",\n  \"VpcArn\": \"\",\n  \"SubnetArns\": [],\n  \"Options\": {\n    \"Ipv6Support\": \"\",\n    \"ApplianceModeSupport\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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/vpc-attachments HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 220

{
  "CoreNetworkId": "",
  "VpcArn": "",
  "SubnetArns": [],
  "Options": {
    "Ipv6Support": "",
    "ApplianceModeSupport": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/vpc-attachments")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"CoreNetworkId\": \"\",\n  \"VpcArn\": \"\",\n  \"SubnetArns\": [],\n  \"Options\": {\n    \"Ipv6Support\": \"\",\n    \"ApplianceModeSupport\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/vpc-attachments"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CoreNetworkId\": \"\",\n  \"VpcArn\": \"\",\n  \"SubnetArns\": [],\n  \"Options\": {\n    \"Ipv6Support\": \"\",\n    \"ApplianceModeSupport\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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  \"CoreNetworkId\": \"\",\n  \"VpcArn\": \"\",\n  \"SubnetArns\": [],\n  \"Options\": {\n    \"Ipv6Support\": \"\",\n    \"ApplianceModeSupport\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/vpc-attachments")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/vpc-attachments")
  .header("content-type", "application/json")
  .body("{\n  \"CoreNetworkId\": \"\",\n  \"VpcArn\": \"\",\n  \"SubnetArns\": [],\n  \"Options\": {\n    \"Ipv6Support\": \"\",\n    \"ApplianceModeSupport\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  CoreNetworkId: '',
  VpcArn: '',
  SubnetArns: [],
  Options: {
    Ipv6Support: '',
    ApplianceModeSupport: ''
  },
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  ClientToken: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vpc-attachments',
  headers: {'content-type': 'application/json'},
  data: {
    CoreNetworkId: '',
    VpcArn: '',
    SubnetArns: [],
    Options: {Ipv6Support: '', ApplianceModeSupport: ''},
    Tags: [{Key: '', Value: ''}],
    ClientToken: ''
  }
};

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

const url = '{{baseUrl}}/vpc-attachments';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"CoreNetworkId":"","VpcArn":"","SubnetArns":[],"Options":{"Ipv6Support":"","ApplianceModeSupport":""},"Tags":[{"Key":"","Value":""}],"ClientToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/vpc-attachments',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CoreNetworkId": "",\n  "VpcArn": "",\n  "SubnetArns": [],\n  "Options": {\n    "Ipv6Support": "",\n    "ApplianceModeSupport": ""\n  },\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "ClientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CoreNetworkId\": \"\",\n  \"VpcArn\": \"\",\n  \"SubnetArns\": [],\n  \"Options\": {\n    \"Ipv6Support\": \"\",\n    \"ApplianceModeSupport\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/vpc-attachments")
  .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/vpc-attachments',
  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({
  CoreNetworkId: '',
  VpcArn: '',
  SubnetArns: [],
  Options: {Ipv6Support: '', ApplianceModeSupport: ''},
  Tags: [{Key: '', Value: ''}],
  ClientToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/vpc-attachments',
  headers: {'content-type': 'application/json'},
  body: {
    CoreNetworkId: '',
    VpcArn: '',
    SubnetArns: [],
    Options: {Ipv6Support: '', ApplianceModeSupport: ''},
    Tags: [{Key: '', Value: ''}],
    ClientToken: ''
  },
  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}}/vpc-attachments');

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

req.type('json');
req.send({
  CoreNetworkId: '',
  VpcArn: '',
  SubnetArns: [],
  Options: {
    Ipv6Support: '',
    ApplianceModeSupport: ''
  },
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ],
  ClientToken: ''
});

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}}/vpc-attachments',
  headers: {'content-type': 'application/json'},
  data: {
    CoreNetworkId: '',
    VpcArn: '',
    SubnetArns: [],
    Options: {Ipv6Support: '', ApplianceModeSupport: ''},
    Tags: [{Key: '', Value: ''}],
    ClientToken: ''
  }
};

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

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

const url = '{{baseUrl}}/vpc-attachments';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"CoreNetworkId":"","VpcArn":"","SubnetArns":[],"Options":{"Ipv6Support":"","ApplianceModeSupport":""},"Tags":[{"Key":"","Value":""}],"ClientToken":""}'
};

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 = @{ @"CoreNetworkId": @"",
                              @"VpcArn": @"",
                              @"SubnetArns": @[  ],
                              @"Options": @{ @"Ipv6Support": @"", @"ApplianceModeSupport": @"" },
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"ClientToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/vpc-attachments"]
                                                       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}}/vpc-attachments" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"CoreNetworkId\": \"\",\n  \"VpcArn\": \"\",\n  \"SubnetArns\": [],\n  \"Options\": {\n    \"Ipv6Support\": \"\",\n    \"ApplianceModeSupport\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}" in

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

 "{{baseUrl}}/vpc-attachments",
  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([
    'CoreNetworkId' => '',
    'VpcArn' => '',
    'SubnetArns' => [
        
    ],
    'Options' => [
        'Ipv6Support' => '',
        'ApplianceModeSupport' => ''
    ],
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'ClientToken' => ''
  ]),
  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}}/vpc-attachments', [
  'body' => '{
  "CoreNetworkId": "",
  "VpcArn": "",
  "SubnetArns": [],
  "Options": {
    "Ipv6Support": "",
    "ApplianceModeSupport": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CoreNetworkId' => '',
  'VpcArn' => '',
  'SubnetArns' => [
    
  ],
  'Options' => [
    'Ipv6Support' => '',
    'ApplianceModeSupport' => ''
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'ClientToken' => ''
]));

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

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

append(json_encode([
  'CoreNetworkId' => '',
  'VpcArn' => '',
  'SubnetArns' => [
    
  ],
  'Options' => [
    'Ipv6Support' => '',
    'ApplianceModeSupport' => ''
  ],
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'ClientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/vpc-attachments');
$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}}/vpc-attachments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CoreNetworkId": "",
  "VpcArn": "",
  "SubnetArns": [],
  "Options": {
    "Ipv6Support": "",
    "ApplianceModeSupport": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/vpc-attachments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CoreNetworkId": "",
  "VpcArn": "",
  "SubnetArns": [],
  "Options": {
    "Ipv6Support": "",
    "ApplianceModeSupport": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}'

import http.client

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

payload = "{\n  \"CoreNetworkId\": \"\",\n  \"VpcArn\": \"\",\n  \"SubnetArns\": [],\n  \"Options\": {\n    \"Ipv6Support\": \"\",\n    \"ApplianceModeSupport\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/vpc-attachments", payload, headers)

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

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

import requests

url = "{{baseUrl}}/vpc-attachments"

payload = {
    "CoreNetworkId": "",
    "VpcArn": "",
    "SubnetArns": [],
    "Options": {
        "Ipv6Support": "",
        "ApplianceModeSupport": ""
    },
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "ClientToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/vpc-attachments"

payload <- "{\n  \"CoreNetworkId\": \"\",\n  \"VpcArn\": \"\",\n  \"SubnetArns\": [],\n  \"Options\": {\n    \"Ipv6Support\": \"\",\n    \"ApplianceModeSupport\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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}}/vpc-attachments")

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  \"CoreNetworkId\": \"\",\n  \"VpcArn\": \"\",\n  \"SubnetArns\": [],\n  \"Options\": {\n    \"Ipv6Support\": \"\",\n    \"ApplianceModeSupport\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\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/vpc-attachments') do |req|
  req.body = "{\n  \"CoreNetworkId\": \"\",\n  \"VpcArn\": \"\",\n  \"SubnetArns\": [],\n  \"Options\": {\n    \"Ipv6Support\": \"\",\n    \"ApplianceModeSupport\": \"\"\n  },\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"ClientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "CoreNetworkId": "",
        "VpcArn": "",
        "SubnetArns": (),
        "Options": json!({
            "Ipv6Support": "",
            "ApplianceModeSupport": ""
        }),
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "ClientToken": ""
    });

    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 '{
  "CoreNetworkId": "",
  "VpcArn": "",
  "SubnetArns": [],
  "Options": {
    "Ipv6Support": "",
    "ApplianceModeSupport": ""
  },
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "ClientToken": ""
}' |  \
  http POST {{baseUrl}}/vpc-attachments \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "CoreNetworkId": "",\n  "VpcArn": "",\n  "SubnetArns": [],\n  "Options": {\n    "Ipv6Support": "",\n    "ApplianceModeSupport": ""\n  },\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "ClientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/vpc-attachments

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "CoreNetworkId": "",
  "VpcArn": "",
  "SubnetArns": [],
  "Options": [
    "Ipv6Support": "",
    "ApplianceModeSupport": ""
  ],
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "ClientToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/vpc-attachments")! 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}}/attachments/:attachmentId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/attachments/:attachmentId")

require "http/client"

url = "{{baseUrl}}/attachments/:attachmentId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/attachments/:attachmentId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/attachments/:attachmentId'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/attachments/:attachmentId")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/attachments/:attachmentId');

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}}/attachments/:attachmentId'};

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

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

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

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

 "{{baseUrl}}/attachments/:attachmentId",
  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}}/attachments/:attachmentId');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/attachments/:attachmentId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/attachments/:attachmentId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/attachments/:attachmentId")

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

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

import requests

url = "{{baseUrl}}/attachments/:attachmentId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/attachments/:attachmentId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/attachments/:attachmentId")

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

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

    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}}/attachments/:attachmentId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/attachments/:attachmentId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/attachments/:attachmentId")! 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}}/connect-peers/:connectPeerId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/connect-peers/:connectPeerId")

require "http/client"

url = "{{baseUrl}}/connect-peers/:connectPeerId"

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

var client = new RestClient("{{baseUrl}}/connect-peers/:connectPeerId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/connect-peers/:connectPeerId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/connect-peers/:connectPeerId'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/connect-peers/:connectPeerId")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/connect-peers/:connectPeerId');

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}}/connect-peers/:connectPeerId'
};

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

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

const url = '{{baseUrl}}/connect-peers/:connectPeerId';
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}}/connect-peers/:connectPeerId"]
                                                       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}}/connect-peers/:connectPeerId" in

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

 "{{baseUrl}}/connect-peers/:connectPeerId",
  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}}/connect-peers/:connectPeerId');

echo $response->getBody();

setUrl('{{baseUrl}}/connect-peers/:connectPeerId');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/connect-peers/:connectPeerId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/connect-peers/:connectPeerId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/connect-peers/:connectPeerId")

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

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

import requests

url = "{{baseUrl}}/connect-peers/:connectPeerId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/connect-peers/:connectPeerId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/connect-peers/:connectPeerId")

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/connect-peers/:connectPeerId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

    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}}/connect-peers/:connectPeerId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/connect-peers/:connectPeerId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/connect-peers/:connectPeerId")! 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}}/global-networks/:globalNetworkId/connections/:connectionId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/global-networks/:globalNetworkId/connections/:connectionId")

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/connections/:connectionId"

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

var client = new RestClient("{{baseUrl}}/global-networks/:globalNetworkId/connections/:connectionId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/connections/:connectionId"

	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/global-networks/:globalNetworkId/connections/:connectionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/global-networks/:globalNetworkId/connections/:connectionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/global-networks/:globalNetworkId/connections/:connectionId")
  .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}}/global-networks/:globalNetworkId/connections/:connectionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/connections/:connectionId'
};

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId/connections/:connectionId';
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}}/global-networks/:globalNetworkId/connections/:connectionId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/connections/:connectionId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/global-networks/:globalNetworkId/connections/:connectionId',
  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}}/global-networks/:globalNetworkId/connections/:connectionId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/global-networks/:globalNetworkId/connections/:connectionId');

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}}/global-networks/:globalNetworkId/connections/:connectionId'
};

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

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId/connections/:connectionId';
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}}/global-networks/:globalNetworkId/connections/:connectionId"]
                                                       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}}/global-networks/:globalNetworkId/connections/:connectionId" in

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

 "{{baseUrl}}/global-networks/:globalNetworkId/connections/:connectionId",
  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}}/global-networks/:globalNetworkId/connections/:connectionId');

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/connections/:connectionId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/connections/:connectionId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/global-networks/:globalNetworkId/connections/:connectionId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/connections/:connectionId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/global-networks/:globalNetworkId/connections/:connectionId")

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

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

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/connections/:connectionId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/connections/:connectionId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks/:globalNetworkId/connections/:connectionId")

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/global-networks/:globalNetworkId/connections/:connectionId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/connections/:connectionId";

    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}}/global-networks/:globalNetworkId/connections/:connectionId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/connections/:connectionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/connections/:connectionId")! 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}}/core-networks/:coreNetworkId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/core-networks/:coreNetworkId")

require "http/client"

url = "{{baseUrl}}/core-networks/:coreNetworkId"

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

var client = new RestClient("{{baseUrl}}/core-networks/:coreNetworkId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/core-networks/:coreNetworkId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/core-networks/:coreNetworkId'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/core-networks/:coreNetworkId")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/core-networks/:coreNetworkId');

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}}/core-networks/:coreNetworkId'
};

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

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

const url = '{{baseUrl}}/core-networks/:coreNetworkId';
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}}/core-networks/:coreNetworkId"]
                                                       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}}/core-networks/:coreNetworkId" in

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

 "{{baseUrl}}/core-networks/:coreNetworkId",
  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}}/core-networks/:coreNetworkId');

echo $response->getBody();

setUrl('{{baseUrl}}/core-networks/:coreNetworkId');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/core-networks/:coreNetworkId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/core-networks/:coreNetworkId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/core-networks/:coreNetworkId")

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

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

import requests

url = "{{baseUrl}}/core-networks/:coreNetworkId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/core-networks/:coreNetworkId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/core-networks/:coreNetworkId")

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/core-networks/:coreNetworkId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

    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}}/core-networks/:coreNetworkId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/core-networks/:coreNetworkId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/core-networks/:coreNetworkId")! 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}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId")

require "http/client"

url = "{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId"

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}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId"

	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/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId"))
    .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}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId")
  .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}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId'
};

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

const url = '{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId';
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}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId',
  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}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId');

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}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId'
};

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

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

const url = '{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId';
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}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId"]
                                                       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}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId" in

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

 "{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId",
  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}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId');

echo $response->getBody();

setUrl('{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId")

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

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

import requests

url = "{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId")

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/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId";

    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}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy-versions/:policyVersionId")! 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}}/global-networks/:globalNetworkId/devices/:deviceId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/global-networks/:globalNetworkId/devices/:deviceId")

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/devices/:deviceId"

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

var client = new RestClient("{{baseUrl}}/global-networks/:globalNetworkId/devices/:deviceId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/devices/:deviceId"

	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/global-networks/:globalNetworkId/devices/:deviceId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/global-networks/:globalNetworkId/devices/:deviceId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/global-networks/:globalNetworkId/devices/:deviceId")
  .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}}/global-networks/:globalNetworkId/devices/:deviceId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/devices/:deviceId'
};

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId/devices/:deviceId';
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}}/global-networks/:globalNetworkId/devices/:deviceId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/devices/:deviceId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/global-networks/:globalNetworkId/devices/:deviceId',
  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}}/global-networks/:globalNetworkId/devices/:deviceId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/global-networks/:globalNetworkId/devices/:deviceId');

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}}/global-networks/:globalNetworkId/devices/:deviceId'
};

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

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId/devices/:deviceId';
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}}/global-networks/:globalNetworkId/devices/:deviceId"]
                                                       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}}/global-networks/:globalNetworkId/devices/:deviceId" in

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

 "{{baseUrl}}/global-networks/:globalNetworkId/devices/:deviceId",
  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}}/global-networks/:globalNetworkId/devices/:deviceId');

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/devices/:deviceId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/devices/:deviceId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/global-networks/:globalNetworkId/devices/:deviceId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/devices/:deviceId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/global-networks/:globalNetworkId/devices/:deviceId")

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

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

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/devices/:deviceId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/devices/:deviceId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks/:globalNetworkId/devices/:deviceId")

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/global-networks/:globalNetworkId/devices/:deviceId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/devices/:deviceId";

    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}}/global-networks/:globalNetworkId/devices/:deviceId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/devices/:deviceId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/devices/:deviceId")! 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}}/global-networks/:globalNetworkId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/global-networks/:globalNetworkId")

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId"

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

var client = new RestClient("{{baseUrl}}/global-networks/:globalNetworkId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/global-networks/:globalNetworkId'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/global-networks/:globalNetworkId');

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}}/global-networks/:globalNetworkId'
};

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

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId';
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}}/global-networks/:globalNetworkId"]
                                                       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}}/global-networks/:globalNetworkId" in

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

 "{{baseUrl}}/global-networks/:globalNetworkId",
  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}}/global-networks/:globalNetworkId');

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/global-networks/:globalNetworkId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/global-networks/:globalNetworkId")

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

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

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks/:globalNetworkId")

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/global-networks/:globalNetworkId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

    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}}/global-networks/:globalNetworkId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId")! 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}}/global-networks/:globalNetworkId/links/:linkId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/global-networks/:globalNetworkId/links/:linkId")

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/links/:linkId"

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

var client = new RestClient("{{baseUrl}}/global-networks/:globalNetworkId/links/:linkId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/links/:linkId"

	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/global-networks/:globalNetworkId/links/:linkId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/global-networks/:globalNetworkId/links/:linkId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/global-networks/:globalNetworkId/links/:linkId")
  .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}}/global-networks/:globalNetworkId/links/:linkId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/links/:linkId'
};

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId/links/:linkId';
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}}/global-networks/:globalNetworkId/links/:linkId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/links/:linkId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/global-networks/:globalNetworkId/links/:linkId',
  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}}/global-networks/:globalNetworkId/links/:linkId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/global-networks/:globalNetworkId/links/:linkId');

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}}/global-networks/:globalNetworkId/links/:linkId'
};

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

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId/links/:linkId';
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}}/global-networks/:globalNetworkId/links/:linkId"]
                                                       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}}/global-networks/:globalNetworkId/links/:linkId" in

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

 "{{baseUrl}}/global-networks/:globalNetworkId/links/:linkId",
  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}}/global-networks/:globalNetworkId/links/:linkId');

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/links/:linkId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/links/:linkId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/global-networks/:globalNetworkId/links/:linkId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/links/:linkId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/global-networks/:globalNetworkId/links/:linkId")

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

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

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/links/:linkId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/links/:linkId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks/:globalNetworkId/links/:linkId")

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/global-networks/:globalNetworkId/links/:linkId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/links/:linkId";

    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}}/global-networks/:globalNetworkId/links/:linkId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/links/:linkId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/links/:linkId")! 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}}/peerings/:peeringId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/peerings/:peeringId")

require "http/client"

url = "{{baseUrl}}/peerings/:peeringId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/peerings/:peeringId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/peerings/:peeringId'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/peerings/:peeringId")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/peerings/:peeringId');

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}}/peerings/:peeringId'};

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

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

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

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

 "{{baseUrl}}/peerings/:peeringId",
  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}}/peerings/:peeringId');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/peerings/:peeringId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/peerings/:peeringId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/peerings/:peeringId")

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

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

import requests

url = "{{baseUrl}}/peerings/:peeringId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/peerings/:peeringId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/peerings/:peeringId")

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

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

    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}}/peerings/:peeringId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/peerings/:peeringId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/peerings/:peeringId")! 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}}/resource-policy/:resourceArn");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/resource-policy/:resourceArn")

require "http/client"

url = "{{baseUrl}}/resource-policy/:resourceArn"

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

var client = new RestClient("{{baseUrl}}/resource-policy/:resourceArn");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/resource-policy/:resourceArn"

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

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

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/resource-policy/:resourceArn")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/resource-policy/:resourceArn');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/resource-policy/:resourceArn'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resource-policy/:resourceArn")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource-policy/:resourceArn',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/resource-policy/:resourceArn'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/resource-policy/:resourceArn');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/resource-policy/:resourceArn'
};

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

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

const url = '{{baseUrl}}/resource-policy/:resourceArn';
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}}/resource-policy/:resourceArn"]
                                                       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}}/resource-policy/:resourceArn" in

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

 "{{baseUrl}}/resource-policy/:resourceArn",
  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}}/resource-policy/:resourceArn');

echo $response->getBody();

setUrl('{{baseUrl}}/resource-policy/:resourceArn');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/resource-policy/:resourceArn' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource-policy/:resourceArn' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/resource-policy/:resourceArn")

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

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

import requests

url = "{{baseUrl}}/resource-policy/:resourceArn"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource-policy/:resourceArn"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource-policy/:resourceArn")

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/resource-policy/:resourceArn') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

    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}}/resource-policy/:resourceArn

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/resource-policy/:resourceArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resource-policy/:resourceArn")! 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}}/global-networks/:globalNetworkId/sites/:siteId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/global-networks/:globalNetworkId/sites/:siteId")

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/sites/:siteId"

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

var client = new RestClient("{{baseUrl}}/global-networks/:globalNetworkId/sites/:siteId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/sites/:siteId"

	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/global-networks/:globalNetworkId/sites/:siteId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/global-networks/:globalNetworkId/sites/:siteId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/global-networks/:globalNetworkId/sites/:siteId")
  .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}}/global-networks/:globalNetworkId/sites/:siteId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/sites/:siteId'
};

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId/sites/:siteId';
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}}/global-networks/:globalNetworkId/sites/:siteId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/sites/:siteId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/global-networks/:globalNetworkId/sites/:siteId',
  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}}/global-networks/:globalNetworkId/sites/:siteId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/global-networks/:globalNetworkId/sites/:siteId');

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}}/global-networks/:globalNetworkId/sites/:siteId'
};

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

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId/sites/:siteId';
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}}/global-networks/:globalNetworkId/sites/:siteId"]
                                                       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}}/global-networks/:globalNetworkId/sites/:siteId" in

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

 "{{baseUrl}}/global-networks/:globalNetworkId/sites/:siteId",
  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}}/global-networks/:globalNetworkId/sites/:siteId');

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/sites/:siteId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/sites/:siteId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/global-networks/:globalNetworkId/sites/:siteId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/sites/:siteId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/global-networks/:globalNetworkId/sites/:siteId")

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

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

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/sites/:siteId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/sites/:siteId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks/:globalNetworkId/sites/:siteId")

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/global-networks/:globalNetworkId/sites/:siteId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/sites/:siteId";

    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}}/global-networks/:globalNetworkId/sites/:siteId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/sites/:siteId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/sites/:siteId")! 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}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn")

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn"

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}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn"

	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/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn"))
    .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}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn")
  .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}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn'
};

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn';
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}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn',
  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}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn');

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}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn'
};

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

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

const url = '{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn';
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}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn"]
                                                       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}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn" in

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

 "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn",
  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}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn');

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn")

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

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

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn")

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/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn";

    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}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-registrations/:transitGatewayArn")! 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}}/global-networks");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/global-networks")

require "http/client"

url = "{{baseUrl}}/global-networks"

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}}/global-networks"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/global-networks");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/global-networks"

	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/global-networks HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/global-networks")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-networks"))
    .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}}/global-networks")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/global-networks")
  .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}}/global-networks');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/global-networks'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/global-networks';
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}}/global-networks',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/global-networks")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/global-networks',
  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}}/global-networks'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/global-networks');

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}}/global-networks'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/global-networks';
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}}/global-networks"]
                                                       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}}/global-networks" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/global-networks",
  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}}/global-networks');

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/global-networks');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/global-networks' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/global-networks")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/global-networks"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks")

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/global-networks') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/global-networks

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/global-networks

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks")! 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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId")

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId"

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}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId"

	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/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId"))
    .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}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId")
  .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}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId';
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}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId',
  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}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId');

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}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId';
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}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId"]
                                                       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}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId",
  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}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId');

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId")

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/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId";

    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}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations/:connectPeerId")! 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}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn")

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn"

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}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn"

	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/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn"))
    .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}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn")
  .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}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn';
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}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn',
  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}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn');

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}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn';
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}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn"]
                                                       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}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn",
  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}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn');

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn")

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/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn";

    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}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations/:customerGatewayArn")! 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}}/global-networks/:globalNetworkId/link-associations?deviceId=&linkId=#deviceId&linkId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/global-networks/:globalNetworkId/link-associations#deviceId&linkId" {:query-params {:deviceId ""
                                                                                                                                :linkId ""}})

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/link-associations?deviceId=&linkId=#deviceId&linkId"

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}}/global-networks/:globalNetworkId/link-associations?deviceId=&linkId=#deviceId&linkId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/global-networks/:globalNetworkId/link-associations?deviceId=&linkId=#deviceId&linkId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/link-associations?deviceId=&linkId=#deviceId&linkId"

	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/global-networks/:globalNetworkId/link-associations?deviceId=&linkId= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/global-networks/:globalNetworkId/link-associations?deviceId=&linkId=#deviceId&linkId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-networks/:globalNetworkId/link-associations?deviceId=&linkId=#deviceId&linkId"))
    .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}}/global-networks/:globalNetworkId/link-associations?deviceId=&linkId=#deviceId&linkId")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/global-networks/:globalNetworkId/link-associations?deviceId=&linkId=#deviceId&linkId")
  .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}}/global-networks/:globalNetworkId/link-associations?deviceId=&linkId=#deviceId&linkId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/link-associations#deviceId&linkId',
  params: {deviceId: '', linkId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/global-networks/:globalNetworkId/link-associations?deviceId=&linkId=#deviceId&linkId';
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}}/global-networks/:globalNetworkId/link-associations?deviceId=&linkId=#deviceId&linkId',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/link-associations?deviceId=&linkId=#deviceId&linkId")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/global-networks/:globalNetworkId/link-associations?deviceId=&linkId=',
  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}}/global-networks/:globalNetworkId/link-associations#deviceId&linkId',
  qs: {deviceId: '', linkId: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/global-networks/:globalNetworkId/link-associations#deviceId&linkId');

req.query({
  deviceId: '',
  linkId: ''
});

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}}/global-networks/:globalNetworkId/link-associations#deviceId&linkId',
  params: {deviceId: '', linkId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/global-networks/:globalNetworkId/link-associations?deviceId=&linkId=#deviceId&linkId';
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}}/global-networks/:globalNetworkId/link-associations?deviceId=&linkId=#deviceId&linkId"]
                                                       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}}/global-networks/:globalNetworkId/link-associations?deviceId=&linkId=#deviceId&linkId" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/global-networks/:globalNetworkId/link-associations?deviceId=&linkId=#deviceId&linkId",
  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}}/global-networks/:globalNetworkId/link-associations?deviceId=&linkId=#deviceId&linkId');

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/link-associations#deviceId&linkId');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'deviceId' => '',
  'linkId' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/link-associations#deviceId&linkId');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'deviceId' => '',
  'linkId' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/global-networks/:globalNetworkId/link-associations?deviceId=&linkId=#deviceId&linkId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/link-associations?deviceId=&linkId=#deviceId&linkId' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/global-networks/:globalNetworkId/link-associations?deviceId=&linkId=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/link-associations#deviceId&linkId"

querystring = {"deviceId":"","linkId":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/link-associations#deviceId&linkId"

queryString <- list(
  deviceId = "",
  linkId = ""
)

response <- VERB("DELETE", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks/:globalNetworkId/link-associations?deviceId=&linkId=#deviceId&linkId")

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/global-networks/:globalNetworkId/link-associations') do |req|
  req.params['deviceId'] = ''
  req.params['linkId'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/link-associations#deviceId&linkId";

    let querystring = [
        ("deviceId", ""),
        ("linkId", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE '{{baseUrl}}/global-networks/:globalNetworkId/link-associations?deviceId=&linkId=#deviceId&linkId'

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/global-networks/:globalNetworkId/link-associations?deviceId=&linkId=#deviceId&linkId'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/link-associations?deviceId=&linkId=#deviceId&linkId")! 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}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn")

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn"

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}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn"

	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/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn"))
    .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}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn")
  .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}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn';
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}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn',
  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}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn');

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}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn';
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}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn"]
                                                       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}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn",
  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}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn');

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn")

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/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn";

    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}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/transit-gateway-connect-peer-associations/:transitGatewayConnectPeerArn")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute")

require "http/client"

url = "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute"

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}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute"

	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/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute"))
    .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}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute")
  .post(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute")
  .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}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute';
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}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute',
  method: 'POST',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute")
  .post(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute',
  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}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute');

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}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute';
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}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute"]
                                                       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}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute" in

Client.call `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute",
  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}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute');

echo $response->getBody();

setUrl('{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute');
$request->setMethod(HTTP_METH_POST);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute' -Method POST 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute' -Method POST 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("POST", "/baseUrl/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute"

response <- VERB("POST", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute")

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/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute";

    let client = reqwest::Client::new();
    let response = client.post(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http POST {{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId/execute")! 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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/connect-attachments/:attachmentId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/connect-attachments/:attachmentId")

require "http/client"

url = "{{baseUrl}}/connect-attachments/:attachmentId"

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}}/connect-attachments/:attachmentId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/connect-attachments/:attachmentId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/connect-attachments/:attachmentId"

	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/connect-attachments/:attachmentId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/connect-attachments/:attachmentId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/connect-attachments/:attachmentId"))
    .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}}/connect-attachments/:attachmentId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/connect-attachments/:attachmentId")
  .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}}/connect-attachments/:attachmentId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/connect-attachments/:attachmentId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/connect-attachments/:attachmentId';
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}}/connect-attachments/:attachmentId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/connect-attachments/:attachmentId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/connect-attachments/:attachmentId',
  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}}/connect-attachments/:attachmentId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/connect-attachments/:attachmentId');

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}}/connect-attachments/:attachmentId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/connect-attachments/:attachmentId';
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}}/connect-attachments/:attachmentId"]
                                                       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}}/connect-attachments/:attachmentId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/connect-attachments/:attachmentId",
  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}}/connect-attachments/:attachmentId');

echo $response->getBody();

setUrl('{{baseUrl}}/connect-attachments/:attachmentId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/connect-attachments/:attachmentId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/connect-attachments/:attachmentId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/connect-attachments/:attachmentId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/connect-attachments/:attachmentId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/connect-attachments/:attachmentId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/connect-attachments/:attachmentId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/connect-attachments/:attachmentId")

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/connect-attachments/:attachmentId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/connect-attachments/:attachmentId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/connect-attachments/:attachmentId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/connect-attachments/:attachmentId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/connect-attachments/:attachmentId")! 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}}/connect-peers/:connectPeerId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/connect-peers/:connectPeerId")

require "http/client"

url = "{{baseUrl}}/connect-peers/:connectPeerId"

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}}/connect-peers/:connectPeerId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/connect-peers/:connectPeerId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/connect-peers/:connectPeerId"

	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/connect-peers/:connectPeerId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/connect-peers/:connectPeerId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/connect-peers/:connectPeerId"))
    .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}}/connect-peers/:connectPeerId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/connect-peers/:connectPeerId")
  .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}}/connect-peers/:connectPeerId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/connect-peers/:connectPeerId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/connect-peers/:connectPeerId';
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}}/connect-peers/:connectPeerId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/connect-peers/:connectPeerId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/connect-peers/:connectPeerId',
  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}}/connect-peers/:connectPeerId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/connect-peers/:connectPeerId');

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}}/connect-peers/:connectPeerId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/connect-peers/:connectPeerId';
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}}/connect-peers/:connectPeerId"]
                                                       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}}/connect-peers/:connectPeerId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/connect-peers/:connectPeerId",
  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}}/connect-peers/:connectPeerId');

echo $response->getBody();

setUrl('{{baseUrl}}/connect-peers/:connectPeerId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/connect-peers/:connectPeerId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/connect-peers/:connectPeerId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/connect-peers/:connectPeerId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/connect-peers/:connectPeerId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/connect-peers/:connectPeerId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/connect-peers/:connectPeerId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/connect-peers/:connectPeerId")

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/connect-peers/:connectPeerId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/connect-peers/:connectPeerId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/connect-peers/:connectPeerId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/connect-peers/:connectPeerId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/connect-peers/:connectPeerId")! 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}}/global-networks/:globalNetworkId/connect-peer-associations");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations")

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations"

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}}/global-networks/:globalNetworkId/connect-peer-associations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations"

	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/global-networks/:globalNetworkId/connect-peer-associations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations"))
    .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}}/global-networks/:globalNetworkId/connect-peer-associations")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations")
  .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}}/global-networks/:globalNetworkId/connect-peer-associations');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations';
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}}/global-networks/:globalNetworkId/connect-peer-associations',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/global-networks/:globalNetworkId/connect-peer-associations',
  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}}/global-networks/:globalNetworkId/connect-peer-associations'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations');

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}}/global-networks/:globalNetworkId/connect-peer-associations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations';
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}}/global-networks/:globalNetworkId/connect-peer-associations"]
                                                       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}}/global-networks/:globalNetworkId/connect-peer-associations" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations",
  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}}/global-networks/:globalNetworkId/connect-peer-associations');

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/global-networks/:globalNetworkId/connect-peer-associations")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations")

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/global-networks/:globalNetworkId/connect-peer-associations') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/connect-peer-associations")! 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}}/global-networks/:globalNetworkId/connections");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/global-networks/:globalNetworkId/connections")

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/connections"

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}}/global-networks/:globalNetworkId/connections"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/global-networks/:globalNetworkId/connections");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/connections"

	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/global-networks/:globalNetworkId/connections HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/global-networks/:globalNetworkId/connections")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-networks/:globalNetworkId/connections"))
    .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}}/global-networks/:globalNetworkId/connections")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/global-networks/:globalNetworkId/connections")
  .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}}/global-networks/:globalNetworkId/connections');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/connections'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/global-networks/:globalNetworkId/connections';
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}}/global-networks/:globalNetworkId/connections',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/connections")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/global-networks/:globalNetworkId/connections',
  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}}/global-networks/:globalNetworkId/connections'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/global-networks/:globalNetworkId/connections');

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}}/global-networks/:globalNetworkId/connections'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/global-networks/:globalNetworkId/connections';
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}}/global-networks/:globalNetworkId/connections"]
                                                       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}}/global-networks/:globalNetworkId/connections" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/global-networks/:globalNetworkId/connections",
  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}}/global-networks/:globalNetworkId/connections');

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/connections');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/connections');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/global-networks/:globalNetworkId/connections' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/connections' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/global-networks/:globalNetworkId/connections")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/connections"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/connections"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks/:globalNetworkId/connections")

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/global-networks/:globalNetworkId/connections') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/connections";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/global-networks/:globalNetworkId/connections

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/connections

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/connections")! 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}}/core-networks/:coreNetworkId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/core-networks/:coreNetworkId")

require "http/client"

url = "{{baseUrl}}/core-networks/:coreNetworkId"

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}}/core-networks/:coreNetworkId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/core-networks/:coreNetworkId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/core-networks/:coreNetworkId"

	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/core-networks/:coreNetworkId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/core-networks/:coreNetworkId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/core-networks/:coreNetworkId"))
    .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}}/core-networks/:coreNetworkId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/core-networks/:coreNetworkId")
  .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}}/core-networks/:coreNetworkId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/core-networks/:coreNetworkId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/core-networks/:coreNetworkId';
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}}/core-networks/:coreNetworkId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/core-networks/:coreNetworkId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/core-networks/:coreNetworkId',
  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}}/core-networks/:coreNetworkId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/core-networks/:coreNetworkId');

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}}/core-networks/:coreNetworkId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/core-networks/:coreNetworkId';
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}}/core-networks/:coreNetworkId"]
                                                       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}}/core-networks/:coreNetworkId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/core-networks/:coreNetworkId",
  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}}/core-networks/:coreNetworkId');

echo $response->getBody();

setUrl('{{baseUrl}}/core-networks/:coreNetworkId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/core-networks/:coreNetworkId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/core-networks/:coreNetworkId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/core-networks/:coreNetworkId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/core-networks/:coreNetworkId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/core-networks/:coreNetworkId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/core-networks/:coreNetworkId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/core-networks/:coreNetworkId")

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/core-networks/:coreNetworkId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/core-networks/:coreNetworkId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/core-networks/:coreNetworkId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/core-networks/:coreNetworkId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/core-networks/:coreNetworkId")! 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}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId")

require "http/client"

url = "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId"

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}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId"

	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/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId"))
    .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}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId")
  .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}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId';
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}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId',
  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}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId');

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}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId';
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}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId"]
                                                       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}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId",
  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}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId');

echo $response->getBody();

setUrl('{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId")

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/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-events/:policyVersionId")! 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}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId")

require "http/client"

url = "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId"

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}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId"

	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/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId"))
    .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}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId")
  .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}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId';
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}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId',
  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}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId');

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}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId';
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}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId"]
                                                       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}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId",
  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}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId');

echo $response->getBody();

setUrl('{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId")

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/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/core-networks/:coreNetworkId/core-network-change-sets/:policyVersionId")! 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}}/core-networks/:coreNetworkId/core-network-policy");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy")

require "http/client"

url = "{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy"

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}}/core-networks/:coreNetworkId/core-network-policy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy"

	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/core-networks/:coreNetworkId/core-network-policy HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy"))
    .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}}/core-networks/:coreNetworkId/core-network-policy")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy")
  .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}}/core-networks/:coreNetworkId/core-network-policy');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy';
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}}/core-networks/:coreNetworkId/core-network-policy',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/core-networks/:coreNetworkId/core-network-policy',
  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}}/core-networks/:coreNetworkId/core-network-policy'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy');

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}}/core-networks/:coreNetworkId/core-network-policy'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy';
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}}/core-networks/:coreNetworkId/core-network-policy"]
                                                       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}}/core-networks/:coreNetworkId/core-network-policy" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy",
  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}}/core-networks/:coreNetworkId/core-network-policy');

echo $response->getBody();

setUrl('{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/core-networks/:coreNetworkId/core-network-policy")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy")

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/core-networks/:coreNetworkId/core-network-policy') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/core-networks/:coreNetworkId/core-network-policy

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/core-networks/:coreNetworkId/core-network-policy

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/core-networks/:coreNetworkId/core-network-policy")! 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}}/global-networks/:globalNetworkId/customer-gateway-associations");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations")

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations"

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}}/global-networks/:globalNetworkId/customer-gateway-associations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations"

	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/global-networks/:globalNetworkId/customer-gateway-associations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations"))
    .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}}/global-networks/:globalNetworkId/customer-gateway-associations")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations")
  .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}}/global-networks/:globalNetworkId/customer-gateway-associations');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations';
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}}/global-networks/:globalNetworkId/customer-gateway-associations',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/global-networks/:globalNetworkId/customer-gateway-associations',
  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}}/global-networks/:globalNetworkId/customer-gateway-associations'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations');

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}}/global-networks/:globalNetworkId/customer-gateway-associations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations';
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}}/global-networks/:globalNetworkId/customer-gateway-associations"]
                                                       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}}/global-networks/:globalNetworkId/customer-gateway-associations" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations",
  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}}/global-networks/:globalNetworkId/customer-gateway-associations');

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/global-networks/:globalNetworkId/customer-gateway-associations")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations")

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/global-networks/:globalNetworkId/customer-gateway-associations') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/customer-gateway-associations")! 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}}/global-networks/:globalNetworkId/devices");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/global-networks/:globalNetworkId/devices")

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/devices"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/global-networks/:globalNetworkId/devices"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/global-networks/:globalNetworkId/devices");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/devices"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/global-networks/:globalNetworkId/devices HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/global-networks/:globalNetworkId/devices")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-networks/:globalNetworkId/devices"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/devices")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/global-networks/:globalNetworkId/devices")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/global-networks/:globalNetworkId/devices');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/devices'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/global-networks/:globalNetworkId/devices';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/global-networks/:globalNetworkId/devices',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/devices")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/global-networks/:globalNetworkId/devices',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/devices'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/global-networks/:globalNetworkId/devices');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/devices'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/global-networks/:globalNetworkId/devices';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/global-networks/:globalNetworkId/devices"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/global-networks/:globalNetworkId/devices" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/global-networks/:globalNetworkId/devices",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/global-networks/:globalNetworkId/devices');

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/devices');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/devices');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/global-networks/:globalNetworkId/devices' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/devices' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/global-networks/:globalNetworkId/devices")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/devices"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/devices"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks/:globalNetworkId/devices")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/global-networks/:globalNetworkId/devices') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/devices";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/global-networks/:globalNetworkId/devices

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/devices

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/devices")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/global-networks/:globalNetworkId/link-associations");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/global-networks/:globalNetworkId/link-associations")

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/link-associations"

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}}/global-networks/:globalNetworkId/link-associations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/global-networks/:globalNetworkId/link-associations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/link-associations"

	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/global-networks/:globalNetworkId/link-associations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/global-networks/:globalNetworkId/link-associations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-networks/:globalNetworkId/link-associations"))
    .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}}/global-networks/:globalNetworkId/link-associations")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/global-networks/:globalNetworkId/link-associations")
  .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}}/global-networks/:globalNetworkId/link-associations');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/link-associations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/global-networks/:globalNetworkId/link-associations';
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}}/global-networks/:globalNetworkId/link-associations',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/link-associations")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/global-networks/:globalNetworkId/link-associations',
  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}}/global-networks/:globalNetworkId/link-associations'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/global-networks/:globalNetworkId/link-associations');

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}}/global-networks/:globalNetworkId/link-associations'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/global-networks/:globalNetworkId/link-associations';
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}}/global-networks/:globalNetworkId/link-associations"]
                                                       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}}/global-networks/:globalNetworkId/link-associations" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/global-networks/:globalNetworkId/link-associations",
  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}}/global-networks/:globalNetworkId/link-associations');

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/link-associations');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/link-associations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/global-networks/:globalNetworkId/link-associations' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/link-associations' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/global-networks/:globalNetworkId/link-associations")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/link-associations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/link-associations"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks/:globalNetworkId/link-associations")

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/global-networks/:globalNetworkId/link-associations') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/link-associations";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/global-networks/:globalNetworkId/link-associations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/link-associations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/link-associations")! 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}}/global-networks/:globalNetworkId/links");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/global-networks/:globalNetworkId/links")

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/links"

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}}/global-networks/:globalNetworkId/links"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/global-networks/:globalNetworkId/links");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/links"

	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/global-networks/:globalNetworkId/links HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/global-networks/:globalNetworkId/links")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-networks/:globalNetworkId/links"))
    .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}}/global-networks/:globalNetworkId/links")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/global-networks/:globalNetworkId/links")
  .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}}/global-networks/:globalNetworkId/links');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/links'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/global-networks/:globalNetworkId/links';
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}}/global-networks/:globalNetworkId/links',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/links")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/global-networks/:globalNetworkId/links',
  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}}/global-networks/:globalNetworkId/links'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/global-networks/:globalNetworkId/links');

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}}/global-networks/:globalNetworkId/links'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/global-networks/:globalNetworkId/links';
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}}/global-networks/:globalNetworkId/links"]
                                                       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}}/global-networks/:globalNetworkId/links" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/global-networks/:globalNetworkId/links",
  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}}/global-networks/:globalNetworkId/links');

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/links');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/links');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/global-networks/:globalNetworkId/links' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/links' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/global-networks/:globalNetworkId/links")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/links"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/links"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks/:globalNetworkId/links")

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/global-networks/:globalNetworkId/links') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/links";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/global-networks/:globalNetworkId/links

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/links

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/links")! 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}}/global-networks/:globalNetworkId/network-resource-count");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/global-networks/:globalNetworkId/network-resource-count")

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/network-resource-count"

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}}/global-networks/:globalNetworkId/network-resource-count"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/global-networks/:globalNetworkId/network-resource-count");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/network-resource-count"

	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/global-networks/:globalNetworkId/network-resource-count HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/global-networks/:globalNetworkId/network-resource-count")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-networks/:globalNetworkId/network-resource-count"))
    .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}}/global-networks/:globalNetworkId/network-resource-count")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/global-networks/:globalNetworkId/network-resource-count")
  .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}}/global-networks/:globalNetworkId/network-resource-count');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/network-resource-count'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/global-networks/:globalNetworkId/network-resource-count';
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}}/global-networks/:globalNetworkId/network-resource-count',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/network-resource-count")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/global-networks/:globalNetworkId/network-resource-count',
  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}}/global-networks/:globalNetworkId/network-resource-count'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/global-networks/:globalNetworkId/network-resource-count');

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}}/global-networks/:globalNetworkId/network-resource-count'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/global-networks/:globalNetworkId/network-resource-count';
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}}/global-networks/:globalNetworkId/network-resource-count"]
                                                       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}}/global-networks/:globalNetworkId/network-resource-count" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/global-networks/:globalNetworkId/network-resource-count",
  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}}/global-networks/:globalNetworkId/network-resource-count');

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/network-resource-count');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/network-resource-count');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/global-networks/:globalNetworkId/network-resource-count' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/network-resource-count' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/global-networks/:globalNetworkId/network-resource-count")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/network-resource-count"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/network-resource-count"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks/:globalNetworkId/network-resource-count")

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/global-networks/:globalNetworkId/network-resource-count') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/network-resource-count";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/global-networks/:globalNetworkId/network-resource-count

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/network-resource-count

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/network-resource-count")! 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}}/global-networks/:globalNetworkId/network-resource-relationships");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/global-networks/:globalNetworkId/network-resource-relationships")

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/network-resource-relationships"

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}}/global-networks/:globalNetworkId/network-resource-relationships"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/global-networks/:globalNetworkId/network-resource-relationships");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/network-resource-relationships"

	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/global-networks/:globalNetworkId/network-resource-relationships HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/global-networks/:globalNetworkId/network-resource-relationships")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-networks/:globalNetworkId/network-resource-relationships"))
    .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}}/global-networks/:globalNetworkId/network-resource-relationships")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/global-networks/:globalNetworkId/network-resource-relationships")
  .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}}/global-networks/:globalNetworkId/network-resource-relationships');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/network-resource-relationships'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/global-networks/:globalNetworkId/network-resource-relationships';
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}}/global-networks/:globalNetworkId/network-resource-relationships',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/network-resource-relationships")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/global-networks/:globalNetworkId/network-resource-relationships',
  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}}/global-networks/:globalNetworkId/network-resource-relationships'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/global-networks/:globalNetworkId/network-resource-relationships');

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}}/global-networks/:globalNetworkId/network-resource-relationships'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/global-networks/:globalNetworkId/network-resource-relationships';
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}}/global-networks/:globalNetworkId/network-resource-relationships"]
                                                       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}}/global-networks/:globalNetworkId/network-resource-relationships" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/global-networks/:globalNetworkId/network-resource-relationships",
  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}}/global-networks/:globalNetworkId/network-resource-relationships');

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/network-resource-relationships');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/network-resource-relationships');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/global-networks/:globalNetworkId/network-resource-relationships' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/network-resource-relationships' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/global-networks/:globalNetworkId/network-resource-relationships")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/network-resource-relationships"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/network-resource-relationships"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks/:globalNetworkId/network-resource-relationships")

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/global-networks/:globalNetworkId/network-resource-relationships') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/network-resource-relationships";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/global-networks/:globalNetworkId/network-resource-relationships

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/network-resource-relationships

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/network-resource-relationships")! 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}}/global-networks/:globalNetworkId/network-resources");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/global-networks/:globalNetworkId/network-resources")

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/network-resources"

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}}/global-networks/:globalNetworkId/network-resources"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/global-networks/:globalNetworkId/network-resources");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/network-resources"

	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/global-networks/:globalNetworkId/network-resources HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/global-networks/:globalNetworkId/network-resources")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-networks/:globalNetworkId/network-resources"))
    .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}}/global-networks/:globalNetworkId/network-resources")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/global-networks/:globalNetworkId/network-resources")
  .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}}/global-networks/:globalNetworkId/network-resources');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/network-resources'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/global-networks/:globalNetworkId/network-resources';
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}}/global-networks/:globalNetworkId/network-resources',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/network-resources")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/global-networks/:globalNetworkId/network-resources',
  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}}/global-networks/:globalNetworkId/network-resources'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/global-networks/:globalNetworkId/network-resources');

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}}/global-networks/:globalNetworkId/network-resources'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/global-networks/:globalNetworkId/network-resources';
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}}/global-networks/:globalNetworkId/network-resources"]
                                                       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}}/global-networks/:globalNetworkId/network-resources" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/global-networks/:globalNetworkId/network-resources",
  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}}/global-networks/:globalNetworkId/network-resources');

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/network-resources');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/network-resources');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/global-networks/:globalNetworkId/network-resources' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/network-resources' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/global-networks/:globalNetworkId/network-resources")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/network-resources"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/network-resources"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks/:globalNetworkId/network-resources")

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/global-networks/:globalNetworkId/network-resources') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/network-resources";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/global-networks/:globalNetworkId/network-resources

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/network-resources

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/network-resources")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/global-networks/:globalNetworkId/network-routes");

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  \"RouteTableIdentifier\": {\n    \"TransitGatewayRouteTableArn\": \"\",\n    \"CoreNetworkSegmentEdge\": \"\"\n  },\n  \"ExactCidrMatches\": [],\n  \"LongestPrefixMatches\": [],\n  \"SubnetOfMatches\": [],\n  \"SupernetOfMatches\": [],\n  \"PrefixListIds\": [],\n  \"States\": [],\n  \"Types\": [],\n  \"DestinationFilters\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/global-networks/:globalNetworkId/network-routes" {:content-type :json
                                                                                            :form-params {:RouteTableIdentifier {:TransitGatewayRouteTableArn ""
                                                                                                                                 :CoreNetworkSegmentEdge ""}
                                                                                                          :ExactCidrMatches []
                                                                                                          :LongestPrefixMatches []
                                                                                                          :SubnetOfMatches []
                                                                                                          :SupernetOfMatches []
                                                                                                          :PrefixListIds []
                                                                                                          :States []
                                                                                                          :Types []
                                                                                                          :DestinationFilters {}}})

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/network-routes"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"RouteTableIdentifier\": {\n    \"TransitGatewayRouteTableArn\": \"\",\n    \"CoreNetworkSegmentEdge\": \"\"\n  },\n  \"ExactCidrMatches\": [],\n  \"LongestPrefixMatches\": [],\n  \"SubnetOfMatches\": [],\n  \"SupernetOfMatches\": [],\n  \"PrefixListIds\": [],\n  \"States\": [],\n  \"Types\": [],\n  \"DestinationFilters\": {}\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}}/global-networks/:globalNetworkId/network-routes"),
    Content = new StringContent("{\n  \"RouteTableIdentifier\": {\n    \"TransitGatewayRouteTableArn\": \"\",\n    \"CoreNetworkSegmentEdge\": \"\"\n  },\n  \"ExactCidrMatches\": [],\n  \"LongestPrefixMatches\": [],\n  \"SubnetOfMatches\": [],\n  \"SupernetOfMatches\": [],\n  \"PrefixListIds\": [],\n  \"States\": [],\n  \"Types\": [],\n  \"DestinationFilters\": {}\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}}/global-networks/:globalNetworkId/network-routes");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"RouteTableIdentifier\": {\n    \"TransitGatewayRouteTableArn\": \"\",\n    \"CoreNetworkSegmentEdge\": \"\"\n  },\n  \"ExactCidrMatches\": [],\n  \"LongestPrefixMatches\": [],\n  \"SubnetOfMatches\": [],\n  \"SupernetOfMatches\": [],\n  \"PrefixListIds\": [],\n  \"States\": [],\n  \"Types\": [],\n  \"DestinationFilters\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/network-routes"

	payload := strings.NewReader("{\n  \"RouteTableIdentifier\": {\n    \"TransitGatewayRouteTableArn\": \"\",\n    \"CoreNetworkSegmentEdge\": \"\"\n  },\n  \"ExactCidrMatches\": [],\n  \"LongestPrefixMatches\": [],\n  \"SubnetOfMatches\": [],\n  \"SupernetOfMatches\": [],\n  \"PrefixListIds\": [],\n  \"States\": [],\n  \"Types\": [],\n  \"DestinationFilters\": {}\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/global-networks/:globalNetworkId/network-routes HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 297

{
  "RouteTableIdentifier": {
    "TransitGatewayRouteTableArn": "",
    "CoreNetworkSegmentEdge": ""
  },
  "ExactCidrMatches": [],
  "LongestPrefixMatches": [],
  "SubnetOfMatches": [],
  "SupernetOfMatches": [],
  "PrefixListIds": [],
  "States": [],
  "Types": [],
  "DestinationFilters": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/global-networks/:globalNetworkId/network-routes")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"RouteTableIdentifier\": {\n    \"TransitGatewayRouteTableArn\": \"\",\n    \"CoreNetworkSegmentEdge\": \"\"\n  },\n  \"ExactCidrMatches\": [],\n  \"LongestPrefixMatches\": [],\n  \"SubnetOfMatches\": [],\n  \"SupernetOfMatches\": [],\n  \"PrefixListIds\": [],\n  \"States\": [],\n  \"Types\": [],\n  \"DestinationFilters\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-networks/:globalNetworkId/network-routes"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"RouteTableIdentifier\": {\n    \"TransitGatewayRouteTableArn\": \"\",\n    \"CoreNetworkSegmentEdge\": \"\"\n  },\n  \"ExactCidrMatches\": [],\n  \"LongestPrefixMatches\": [],\n  \"SubnetOfMatches\": [],\n  \"SupernetOfMatches\": [],\n  \"PrefixListIds\": [],\n  \"States\": [],\n  \"Types\": [],\n  \"DestinationFilters\": {}\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  \"RouteTableIdentifier\": {\n    \"TransitGatewayRouteTableArn\": \"\",\n    \"CoreNetworkSegmentEdge\": \"\"\n  },\n  \"ExactCidrMatches\": [],\n  \"LongestPrefixMatches\": [],\n  \"SubnetOfMatches\": [],\n  \"SupernetOfMatches\": [],\n  \"PrefixListIds\": [],\n  \"States\": [],\n  \"Types\": [],\n  \"DestinationFilters\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/network-routes")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/global-networks/:globalNetworkId/network-routes")
  .header("content-type", "application/json")
  .body("{\n  \"RouteTableIdentifier\": {\n    \"TransitGatewayRouteTableArn\": \"\",\n    \"CoreNetworkSegmentEdge\": \"\"\n  },\n  \"ExactCidrMatches\": [],\n  \"LongestPrefixMatches\": [],\n  \"SubnetOfMatches\": [],\n  \"SupernetOfMatches\": [],\n  \"PrefixListIds\": [],\n  \"States\": [],\n  \"Types\": [],\n  \"DestinationFilters\": {}\n}")
  .asString();

const data = JSON.stringify({
  RouteTableIdentifier: {
    TransitGatewayRouteTableArn: '',
    CoreNetworkSegmentEdge: ''
  },
  ExactCidrMatches: [],
  LongestPrefixMatches: [],
  SubnetOfMatches: [],
  SupernetOfMatches: [],
  PrefixListIds: [],
  States: [],
  Types: [],
  DestinationFilters: {}
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/global-networks/:globalNetworkId/network-routes');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/network-routes',
  headers: {'content-type': 'application/json'},
  data: {
    RouteTableIdentifier: {TransitGatewayRouteTableArn: '', CoreNetworkSegmentEdge: ''},
    ExactCidrMatches: [],
    LongestPrefixMatches: [],
    SubnetOfMatches: [],
    SupernetOfMatches: [],
    PrefixListIds: [],
    States: [],
    Types: [],
    DestinationFilters: {}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/global-networks/:globalNetworkId/network-routes';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"RouteTableIdentifier":{"TransitGatewayRouteTableArn":"","CoreNetworkSegmentEdge":""},"ExactCidrMatches":[],"LongestPrefixMatches":[],"SubnetOfMatches":[],"SupernetOfMatches":[],"PrefixListIds":[],"States":[],"Types":[],"DestinationFilters":{}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/global-networks/:globalNetworkId/network-routes',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "RouteTableIdentifier": {\n    "TransitGatewayRouteTableArn": "",\n    "CoreNetworkSegmentEdge": ""\n  },\n  "ExactCidrMatches": [],\n  "LongestPrefixMatches": [],\n  "SubnetOfMatches": [],\n  "SupernetOfMatches": [],\n  "PrefixListIds": [],\n  "States": [],\n  "Types": [],\n  "DestinationFilters": {}\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"RouteTableIdentifier\": {\n    \"TransitGatewayRouteTableArn\": \"\",\n    \"CoreNetworkSegmentEdge\": \"\"\n  },\n  \"ExactCidrMatches\": [],\n  \"LongestPrefixMatches\": [],\n  \"SubnetOfMatches\": [],\n  \"SupernetOfMatches\": [],\n  \"PrefixListIds\": [],\n  \"States\": [],\n  \"Types\": [],\n  \"DestinationFilters\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/network-routes")
  .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/global-networks/:globalNetworkId/network-routes',
  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({
  RouteTableIdentifier: {TransitGatewayRouteTableArn: '', CoreNetworkSegmentEdge: ''},
  ExactCidrMatches: [],
  LongestPrefixMatches: [],
  SubnetOfMatches: [],
  SupernetOfMatches: [],
  PrefixListIds: [],
  States: [],
  Types: [],
  DestinationFilters: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/network-routes',
  headers: {'content-type': 'application/json'},
  body: {
    RouteTableIdentifier: {TransitGatewayRouteTableArn: '', CoreNetworkSegmentEdge: ''},
    ExactCidrMatches: [],
    LongestPrefixMatches: [],
    SubnetOfMatches: [],
    SupernetOfMatches: [],
    PrefixListIds: [],
    States: [],
    Types: [],
    DestinationFilters: {}
  },
  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}}/global-networks/:globalNetworkId/network-routes');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  RouteTableIdentifier: {
    TransitGatewayRouteTableArn: '',
    CoreNetworkSegmentEdge: ''
  },
  ExactCidrMatches: [],
  LongestPrefixMatches: [],
  SubnetOfMatches: [],
  SupernetOfMatches: [],
  PrefixListIds: [],
  States: [],
  Types: [],
  DestinationFilters: {}
});

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}}/global-networks/:globalNetworkId/network-routes',
  headers: {'content-type': 'application/json'},
  data: {
    RouteTableIdentifier: {TransitGatewayRouteTableArn: '', CoreNetworkSegmentEdge: ''},
    ExactCidrMatches: [],
    LongestPrefixMatches: [],
    SubnetOfMatches: [],
    SupernetOfMatches: [],
    PrefixListIds: [],
    States: [],
    Types: [],
    DestinationFilters: {}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/global-networks/:globalNetworkId/network-routes';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"RouteTableIdentifier":{"TransitGatewayRouteTableArn":"","CoreNetworkSegmentEdge":""},"ExactCidrMatches":[],"LongestPrefixMatches":[],"SubnetOfMatches":[],"SupernetOfMatches":[],"PrefixListIds":[],"States":[],"Types":[],"DestinationFilters":{}}'
};

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 = @{ @"RouteTableIdentifier": @{ @"TransitGatewayRouteTableArn": @"", @"CoreNetworkSegmentEdge": @"" },
                              @"ExactCidrMatches": @[  ],
                              @"LongestPrefixMatches": @[  ],
                              @"SubnetOfMatches": @[  ],
                              @"SupernetOfMatches": @[  ],
                              @"PrefixListIds": @[  ],
                              @"States": @[  ],
                              @"Types": @[  ],
                              @"DestinationFilters": @{  } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/global-networks/:globalNetworkId/network-routes"]
                                                       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}}/global-networks/:globalNetworkId/network-routes" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"RouteTableIdentifier\": {\n    \"TransitGatewayRouteTableArn\": \"\",\n    \"CoreNetworkSegmentEdge\": \"\"\n  },\n  \"ExactCidrMatches\": [],\n  \"LongestPrefixMatches\": [],\n  \"SubnetOfMatches\": [],\n  \"SupernetOfMatches\": [],\n  \"PrefixListIds\": [],\n  \"States\": [],\n  \"Types\": [],\n  \"DestinationFilters\": {}\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/global-networks/:globalNetworkId/network-routes",
  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([
    'RouteTableIdentifier' => [
        'TransitGatewayRouteTableArn' => '',
        'CoreNetworkSegmentEdge' => ''
    ],
    'ExactCidrMatches' => [
        
    ],
    'LongestPrefixMatches' => [
        
    ],
    'SubnetOfMatches' => [
        
    ],
    'SupernetOfMatches' => [
        
    ],
    'PrefixListIds' => [
        
    ],
    'States' => [
        
    ],
    'Types' => [
        
    ],
    'DestinationFilters' => [
        
    ]
  ]),
  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}}/global-networks/:globalNetworkId/network-routes', [
  'body' => '{
  "RouteTableIdentifier": {
    "TransitGatewayRouteTableArn": "",
    "CoreNetworkSegmentEdge": ""
  },
  "ExactCidrMatches": [],
  "LongestPrefixMatches": [],
  "SubnetOfMatches": [],
  "SupernetOfMatches": [],
  "PrefixListIds": [],
  "States": [],
  "Types": [],
  "DestinationFilters": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/network-routes');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'RouteTableIdentifier' => [
    'TransitGatewayRouteTableArn' => '',
    'CoreNetworkSegmentEdge' => ''
  ],
  'ExactCidrMatches' => [
    
  ],
  'LongestPrefixMatches' => [
    
  ],
  'SubnetOfMatches' => [
    
  ],
  'SupernetOfMatches' => [
    
  ],
  'PrefixListIds' => [
    
  ],
  'States' => [
    
  ],
  'Types' => [
    
  ],
  'DestinationFilters' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'RouteTableIdentifier' => [
    'TransitGatewayRouteTableArn' => '',
    'CoreNetworkSegmentEdge' => ''
  ],
  'ExactCidrMatches' => [
    
  ],
  'LongestPrefixMatches' => [
    
  ],
  'SubnetOfMatches' => [
    
  ],
  'SupernetOfMatches' => [
    
  ],
  'PrefixListIds' => [
    
  ],
  'States' => [
    
  ],
  'Types' => [
    
  ],
  'DestinationFilters' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/network-routes');
$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}}/global-networks/:globalNetworkId/network-routes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "RouteTableIdentifier": {
    "TransitGatewayRouteTableArn": "",
    "CoreNetworkSegmentEdge": ""
  },
  "ExactCidrMatches": [],
  "LongestPrefixMatches": [],
  "SubnetOfMatches": [],
  "SupernetOfMatches": [],
  "PrefixListIds": [],
  "States": [],
  "Types": [],
  "DestinationFilters": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/network-routes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "RouteTableIdentifier": {
    "TransitGatewayRouteTableArn": "",
    "CoreNetworkSegmentEdge": ""
  },
  "ExactCidrMatches": [],
  "LongestPrefixMatches": [],
  "SubnetOfMatches": [],
  "SupernetOfMatches": [],
  "PrefixListIds": [],
  "States": [],
  "Types": [],
  "DestinationFilters": {}
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"RouteTableIdentifier\": {\n    \"TransitGatewayRouteTableArn\": \"\",\n    \"CoreNetworkSegmentEdge\": \"\"\n  },\n  \"ExactCidrMatches\": [],\n  \"LongestPrefixMatches\": [],\n  \"SubnetOfMatches\": [],\n  \"SupernetOfMatches\": [],\n  \"PrefixListIds\": [],\n  \"States\": [],\n  \"Types\": [],\n  \"DestinationFilters\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/global-networks/:globalNetworkId/network-routes", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/network-routes"

payload = {
    "RouteTableIdentifier": {
        "TransitGatewayRouteTableArn": "",
        "CoreNetworkSegmentEdge": ""
    },
    "ExactCidrMatches": [],
    "LongestPrefixMatches": [],
    "SubnetOfMatches": [],
    "SupernetOfMatches": [],
    "PrefixListIds": [],
    "States": [],
    "Types": [],
    "DestinationFilters": {}
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/network-routes"

payload <- "{\n  \"RouteTableIdentifier\": {\n    \"TransitGatewayRouteTableArn\": \"\",\n    \"CoreNetworkSegmentEdge\": \"\"\n  },\n  \"ExactCidrMatches\": [],\n  \"LongestPrefixMatches\": [],\n  \"SubnetOfMatches\": [],\n  \"SupernetOfMatches\": [],\n  \"PrefixListIds\": [],\n  \"States\": [],\n  \"Types\": [],\n  \"DestinationFilters\": {}\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}}/global-networks/:globalNetworkId/network-routes")

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  \"RouteTableIdentifier\": {\n    \"TransitGatewayRouteTableArn\": \"\",\n    \"CoreNetworkSegmentEdge\": \"\"\n  },\n  \"ExactCidrMatches\": [],\n  \"LongestPrefixMatches\": [],\n  \"SubnetOfMatches\": [],\n  \"SupernetOfMatches\": [],\n  \"PrefixListIds\": [],\n  \"States\": [],\n  \"Types\": [],\n  \"DestinationFilters\": {}\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/global-networks/:globalNetworkId/network-routes') do |req|
  req.body = "{\n  \"RouteTableIdentifier\": {\n    \"TransitGatewayRouteTableArn\": \"\",\n    \"CoreNetworkSegmentEdge\": \"\"\n  },\n  \"ExactCidrMatches\": [],\n  \"LongestPrefixMatches\": [],\n  \"SubnetOfMatches\": [],\n  \"SupernetOfMatches\": [],\n  \"PrefixListIds\": [],\n  \"States\": [],\n  \"Types\": [],\n  \"DestinationFilters\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/network-routes";

    let payload = json!({
        "RouteTableIdentifier": json!({
            "TransitGatewayRouteTableArn": "",
            "CoreNetworkSegmentEdge": ""
        }),
        "ExactCidrMatches": (),
        "LongestPrefixMatches": (),
        "SubnetOfMatches": (),
        "SupernetOfMatches": (),
        "PrefixListIds": (),
        "States": (),
        "Types": (),
        "DestinationFilters": 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 '{
  "RouteTableIdentifier": {
    "TransitGatewayRouteTableArn": "",
    "CoreNetworkSegmentEdge": ""
  },
  "ExactCidrMatches": [],
  "LongestPrefixMatches": [],
  "SubnetOfMatches": [],
  "SupernetOfMatches": [],
  "PrefixListIds": [],
  "States": [],
  "Types": [],
  "DestinationFilters": {}
}' |  \
  http POST {{baseUrl}}/global-networks/:globalNetworkId/network-routes \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "RouteTableIdentifier": {\n    "TransitGatewayRouteTableArn": "",\n    "CoreNetworkSegmentEdge": ""\n  },\n  "ExactCidrMatches": [],\n  "LongestPrefixMatches": [],\n  "SubnetOfMatches": [],\n  "SupernetOfMatches": [],\n  "PrefixListIds": [],\n  "States": [],\n  "Types": [],\n  "DestinationFilters": {}\n}' \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/network-routes

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "RouteTableIdentifier": [
    "TransitGatewayRouteTableArn": "",
    "CoreNetworkSegmentEdge": ""
  ],
  "ExactCidrMatches": [],
  "LongestPrefixMatches": [],
  "SubnetOfMatches": [],
  "SupernetOfMatches": [],
  "PrefixListIds": [],
  "States": [],
  "Types": [],
  "DestinationFilters": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/network-routes")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/global-networks/:globalNetworkId/network-telemetry");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/global-networks/:globalNetworkId/network-telemetry")

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/network-telemetry"

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}}/global-networks/:globalNetworkId/network-telemetry"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/global-networks/:globalNetworkId/network-telemetry");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/network-telemetry"

	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/global-networks/:globalNetworkId/network-telemetry HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/global-networks/:globalNetworkId/network-telemetry")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-networks/:globalNetworkId/network-telemetry"))
    .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}}/global-networks/:globalNetworkId/network-telemetry")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/global-networks/:globalNetworkId/network-telemetry")
  .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}}/global-networks/:globalNetworkId/network-telemetry');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/network-telemetry'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/global-networks/:globalNetworkId/network-telemetry';
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}}/global-networks/:globalNetworkId/network-telemetry',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/network-telemetry")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/global-networks/:globalNetworkId/network-telemetry',
  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}}/global-networks/:globalNetworkId/network-telemetry'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/global-networks/:globalNetworkId/network-telemetry');

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}}/global-networks/:globalNetworkId/network-telemetry'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/global-networks/:globalNetworkId/network-telemetry';
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}}/global-networks/:globalNetworkId/network-telemetry"]
                                                       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}}/global-networks/:globalNetworkId/network-telemetry" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/global-networks/:globalNetworkId/network-telemetry",
  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}}/global-networks/:globalNetworkId/network-telemetry');

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/network-telemetry');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/network-telemetry');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/global-networks/:globalNetworkId/network-telemetry' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/network-telemetry' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/global-networks/:globalNetworkId/network-telemetry")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/network-telemetry"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/network-telemetry"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks/:globalNetworkId/network-telemetry")

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/global-networks/:globalNetworkId/network-telemetry') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/network-telemetry";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/global-networks/:globalNetworkId/network-telemetry

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/network-telemetry

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/network-telemetry")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resource-policy/:resourceArn");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/resource-policy/:resourceArn")

require "http/client"

url = "{{baseUrl}}/resource-policy/:resourceArn"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/resource-policy/:resourceArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/resource-policy/:resourceArn");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resource-policy/:resourceArn"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/resource-policy/:resourceArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/resource-policy/:resourceArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resource-policy/:resourceArn"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/resource-policy/:resourceArn")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/resource-policy/:resourceArn")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/resource-policy/:resourceArn');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/resource-policy/:resourceArn'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resource-policy/:resourceArn';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resource-policy/:resourceArn',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resource-policy/:resourceArn")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource-policy/:resourceArn',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/resource-policy/:resourceArn'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/resource-policy/:resourceArn');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/resource-policy/:resourceArn'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resource-policy/:resourceArn';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resource-policy/:resourceArn"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resource-policy/:resourceArn" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resource-policy/:resourceArn",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/resource-policy/:resourceArn');

echo $response->getBody();

setUrl('{{baseUrl}}/resource-policy/:resourceArn');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/resource-policy/:resourceArn');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/resource-policy/:resourceArn' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource-policy/:resourceArn' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/resource-policy/:resourceArn")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resource-policy/:resourceArn"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource-policy/:resourceArn"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource-policy/:resourceArn")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/resource-policy/:resourceArn') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resource-policy/:resourceArn";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/resource-policy/:resourceArn

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/resource-policy/:resourceArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resource-policy/:resourceArn")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId")

require "http/client"

url = "{{baseUrl}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId"

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}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId"

	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/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId"))
    .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}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId")
  .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}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId';
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}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId',
  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}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId');

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}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId';
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}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId"]
                                                       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}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId",
  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}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId');

echo $response->getBody();

setUrl('{{baseUrl}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId")

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/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/global-networks/:globalNetworkId/route-analyses/:routeAnalysisId")! 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}}/site-to-site-vpn-attachments/:attachmentId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/site-to-site-vpn-attachments/:attachmentId")

require "http/client"

url = "{{baseUrl}}/site-to-site-vpn-attachments/:attachmentId"

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}}/site-to-site-vpn-attachments/:attachmentId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/site-to-site-vpn-attachments/:attachmentId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/site-to-site-vpn-attachments/:attachmentId"

	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/site-to-site-vpn-attachments/:attachmentId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/site-to-site-vpn-attachments/:attachmentId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/site-to-site-vpn-attachments/:attachmentId"))
    .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}}/site-to-site-vpn-attachments/:attachmentId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/site-to-site-vpn-attachments/:attachmentId")
  .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}}/site-to-site-vpn-attachments/:attachmentId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/site-to-site-vpn-attachments/:attachmentId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/site-to-site-vpn-attachments/:attachmentId';
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}}/site-to-site-vpn-attachments/:attachmentId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/site-to-site-vpn-attachments/:attachmentId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/site-to-site-vpn-attachments/:attachmentId',
  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}}/site-to-site-vpn-attachments/:attachmentId'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/site-to-site-vpn-attachments/:attachmentId');

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}}/site-to-site-vpn-attachments/:attachmentId'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/site-to-site-vpn-attachments/:attachmentId';
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}}/site-to-site-vpn-attachments/:attachmentId"]
                                                       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}}/site-to-site-vpn-attachments/:attachmentId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)