Amazon Elastic Kubernetes Servicev2017-11-01

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/clusters/:name/encryption-config/associate");

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  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/clusters/:name/encryption-config/associate" {:content-type :json
                                                                                       :form-params {:encryptionConfig [{:resources ""
                                                                                                                         :provider ""}]
                                                                                                     :clientRequestToken ""}})

require "http/client"

url = "{{baseUrl}}/clusters/:name/encryption-config/associate"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/clusters/:name/encryption-config/associate"),
    Content = new StringContent("{\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/clusters/:name/encryption-config/associate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/clusters/:name/encryption-config/associate"

	payload := strings.NewReader("{\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/clusters/:name/encryption-config/associate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 115

{
  "encryptionConfig": [
    {
      "resources": "",
      "provider": ""
    }
  ],
  "clientRequestToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/clusters/:name/encryption-config/associate")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clusters/:name/encryption-config/associate"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/clusters/:name/encryption-config/associate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/clusters/:name/encryption-config/associate")
  .header("content-type", "application/json")
  .body("{\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  encryptionConfig: [
    {
      resources: '',
      provider: ''
    }
  ],
  clientRequestToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/clusters/:name/encryption-config/associate');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/encryption-config/associate',
  headers: {'content-type': 'application/json'},
  data: {encryptionConfig: [{resources: '', provider: ''}], clientRequestToken: ''}
};

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

const url = '{{baseUrl}}/clusters/:name/encryption-config/associate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"encryptionConfig":[{"resources":"","provider":""}],"clientRequestToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/clusters/:name/encryption-config/associate',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "encryptionConfig": [\n    {\n      "resources": "",\n      "provider": ""\n    }\n  ],\n  "clientRequestToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/clusters/:name/encryption-config/associate")
  .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/clusters/:name/encryption-config/associate',
  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({encryptionConfig: [{resources: '', provider: ''}], clientRequestToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/encryption-config/associate',
  headers: {'content-type': 'application/json'},
  body: {encryptionConfig: [{resources: '', provider: ''}], clientRequestToken: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/clusters/:name/encryption-config/associate');

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

req.type('json');
req.send({
  encryptionConfig: [
    {
      resources: '',
      provider: ''
    }
  ],
  clientRequestToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/encryption-config/associate',
  headers: {'content-type': 'application/json'},
  data: {encryptionConfig: [{resources: '', provider: ''}], clientRequestToken: ''}
};

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

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

const url = '{{baseUrl}}/clusters/:name/encryption-config/associate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"encryptionConfig":[{"resources":"","provider":""}],"clientRequestToken":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"encryptionConfig": @[ @{ @"resources": @"", @"provider": @"" } ],
                              @"clientRequestToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/clusters/:name/encryption-config/associate"]
                                                       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}}/clusters/:name/encryption-config/associate" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}" in

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

 "{{baseUrl}}/clusters/:name/encryption-config/associate",
  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([
    'encryptionConfig' => [
        [
                'resources' => '',
                'provider' => ''
        ]
    ],
    'clientRequestToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/clusters/:name/encryption-config/associate', [
  'body' => '{
  "encryptionConfig": [
    {
      "resources": "",
      "provider": ""
    }
  ],
  "clientRequestToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/clusters/:name/encryption-config/associate');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'encryptionConfig' => [
    [
        'resources' => '',
        'provider' => ''
    ]
  ],
  'clientRequestToken' => ''
]));

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

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

append(json_encode([
  'encryptionConfig' => [
    [
        'resources' => '',
        'provider' => ''
    ]
  ],
  'clientRequestToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/clusters/:name/encryption-config/associate');
$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}}/clusters/:name/encryption-config/associate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "encryptionConfig": [
    {
      "resources": "",
      "provider": ""
    }
  ],
  "clientRequestToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/clusters/:name/encryption-config/associate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "encryptionConfig": [
    {
      "resources": "",
      "provider": ""
    }
  ],
  "clientRequestToken": ""
}'

import http.client

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

payload = "{\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/clusters/:name/encryption-config/associate", payload, headers)

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

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

import requests

url = "{{baseUrl}}/clusters/:name/encryption-config/associate"

payload = {
    "encryptionConfig": [
        {
            "resources": "",
            "provider": ""
        }
    ],
    "clientRequestToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/clusters/:name/encryption-config/associate"

payload <- "{\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clusters/:name/encryption-config/associate")

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  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/clusters/:name/encryption-config/associate') do |req|
  req.body = "{\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/clusters/:name/encryption-config/associate";

    let payload = json!({
        "encryptionConfig": (
            json!({
                "resources": "",
                "provider": ""
            })
        ),
        "clientRequestToken": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "encryptionConfig": [
    {
      "resources": "",
      "provider": ""
    }
  ],
  "clientRequestToken": ""
}' |  \
  http POST {{baseUrl}}/clusters/:name/encryption-config/associate \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "encryptionConfig": [\n    {\n      "resources": "",\n      "provider": ""\n    }\n  ],\n  "clientRequestToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/clusters/:name/encryption-config/associate

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "encryptionConfig": [
    [
      "resources": "",
      "provider": ""
    ]
  ],
  "clientRequestToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clusters/:name/encryption-config/associate")! 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}}/clusters/:name/identity-provider-configs/associate");

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  \"oidc\": {\n    \"identityProviderConfigName\": \"\",\n    \"issuerUrl\": \"\",\n    \"clientId\": \"\",\n    \"usernameClaim\": \"\",\n    \"usernamePrefix\": \"\",\n    \"groupsClaim\": \"\",\n    \"groupsPrefix\": \"\",\n    \"requiredClaims\": \"\"\n  },\n  \"tags\": {},\n  \"clientRequestToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/clusters/:name/identity-provider-configs/associate" {:content-type :json
                                                                                               :form-params {:oidc {:identityProviderConfigName ""
                                                                                                                    :issuerUrl ""
                                                                                                                    :clientId ""
                                                                                                                    :usernameClaim ""
                                                                                                                    :usernamePrefix ""
                                                                                                                    :groupsClaim ""
                                                                                                                    :groupsPrefix ""
                                                                                                                    :requiredClaims ""}
                                                                                                             :tags {}
                                                                                                             :clientRequestToken ""}})

require "http/client"

url = "{{baseUrl}}/clusters/:name/identity-provider-configs/associate"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"oidc\": {\n    \"identityProviderConfigName\": \"\",\n    \"issuerUrl\": \"\",\n    \"clientId\": \"\",\n    \"usernameClaim\": \"\",\n    \"usernamePrefix\": \"\",\n    \"groupsClaim\": \"\",\n    \"groupsPrefix\": \"\",\n    \"requiredClaims\": \"\"\n  },\n  \"tags\": {},\n  \"clientRequestToken\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/clusters/:name/identity-provider-configs/associate"),
    Content = new StringContent("{\n  \"oidc\": {\n    \"identityProviderConfigName\": \"\",\n    \"issuerUrl\": \"\",\n    \"clientId\": \"\",\n    \"usernameClaim\": \"\",\n    \"usernamePrefix\": \"\",\n    \"groupsClaim\": \"\",\n    \"groupsPrefix\": \"\",\n    \"requiredClaims\": \"\"\n  },\n  \"tags\": {},\n  \"clientRequestToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/clusters/:name/identity-provider-configs/associate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"oidc\": {\n    \"identityProviderConfigName\": \"\",\n    \"issuerUrl\": \"\",\n    \"clientId\": \"\",\n    \"usernameClaim\": \"\",\n    \"usernamePrefix\": \"\",\n    \"groupsClaim\": \"\",\n    \"groupsPrefix\": \"\",\n    \"requiredClaims\": \"\"\n  },\n  \"tags\": {},\n  \"clientRequestToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/clusters/:name/identity-provider-configs/associate"

	payload := strings.NewReader("{\n  \"oidc\": {\n    \"identityProviderConfigName\": \"\",\n    \"issuerUrl\": \"\",\n    \"clientId\": \"\",\n    \"usernameClaim\": \"\",\n    \"usernamePrefix\": \"\",\n    \"groupsClaim\": \"\",\n    \"groupsPrefix\": \"\",\n    \"requiredClaims\": \"\"\n  },\n  \"tags\": {},\n  \"clientRequestToken\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/clusters/:name/identity-provider-configs/associate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 263

{
  "oidc": {
    "identityProviderConfigName": "",
    "issuerUrl": "",
    "clientId": "",
    "usernameClaim": "",
    "usernamePrefix": "",
    "groupsClaim": "",
    "groupsPrefix": "",
    "requiredClaims": ""
  },
  "tags": {},
  "clientRequestToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/clusters/:name/identity-provider-configs/associate")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"oidc\": {\n    \"identityProviderConfigName\": \"\",\n    \"issuerUrl\": \"\",\n    \"clientId\": \"\",\n    \"usernameClaim\": \"\",\n    \"usernamePrefix\": \"\",\n    \"groupsClaim\": \"\",\n    \"groupsPrefix\": \"\",\n    \"requiredClaims\": \"\"\n  },\n  \"tags\": {},\n  \"clientRequestToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clusters/:name/identity-provider-configs/associate"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"oidc\": {\n    \"identityProviderConfigName\": \"\",\n    \"issuerUrl\": \"\",\n    \"clientId\": \"\",\n    \"usernameClaim\": \"\",\n    \"usernamePrefix\": \"\",\n    \"groupsClaim\": \"\",\n    \"groupsPrefix\": \"\",\n    \"requiredClaims\": \"\"\n  },\n  \"tags\": {},\n  \"clientRequestToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"oidc\": {\n    \"identityProviderConfigName\": \"\",\n    \"issuerUrl\": \"\",\n    \"clientId\": \"\",\n    \"usernameClaim\": \"\",\n    \"usernamePrefix\": \"\",\n    \"groupsClaim\": \"\",\n    \"groupsPrefix\": \"\",\n    \"requiredClaims\": \"\"\n  },\n  \"tags\": {},\n  \"clientRequestToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/clusters/:name/identity-provider-configs/associate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/clusters/:name/identity-provider-configs/associate")
  .header("content-type", "application/json")
  .body("{\n  \"oidc\": {\n    \"identityProviderConfigName\": \"\",\n    \"issuerUrl\": \"\",\n    \"clientId\": \"\",\n    \"usernameClaim\": \"\",\n    \"usernamePrefix\": \"\",\n    \"groupsClaim\": \"\",\n    \"groupsPrefix\": \"\",\n    \"requiredClaims\": \"\"\n  },\n  \"tags\": {},\n  \"clientRequestToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  oidc: {
    identityProviderConfigName: '',
    issuerUrl: '',
    clientId: '',
    usernameClaim: '',
    usernamePrefix: '',
    groupsClaim: '',
    groupsPrefix: '',
    requiredClaims: ''
  },
  tags: {},
  clientRequestToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/clusters/:name/identity-provider-configs/associate');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/identity-provider-configs/associate',
  headers: {'content-type': 'application/json'},
  data: {
    oidc: {
      identityProviderConfigName: '',
      issuerUrl: '',
      clientId: '',
      usernameClaim: '',
      usernamePrefix: '',
      groupsClaim: '',
      groupsPrefix: '',
      requiredClaims: ''
    },
    tags: {},
    clientRequestToken: ''
  }
};

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

const url = '{{baseUrl}}/clusters/:name/identity-provider-configs/associate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"oidc":{"identityProviderConfigName":"","issuerUrl":"","clientId":"","usernameClaim":"","usernamePrefix":"","groupsClaim":"","groupsPrefix":"","requiredClaims":""},"tags":{},"clientRequestToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/clusters/:name/identity-provider-configs/associate',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "oidc": {\n    "identityProviderConfigName": "",\n    "issuerUrl": "",\n    "clientId": "",\n    "usernameClaim": "",\n    "usernamePrefix": "",\n    "groupsClaim": "",\n    "groupsPrefix": "",\n    "requiredClaims": ""\n  },\n  "tags": {},\n  "clientRequestToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"oidc\": {\n    \"identityProviderConfigName\": \"\",\n    \"issuerUrl\": \"\",\n    \"clientId\": \"\",\n    \"usernameClaim\": \"\",\n    \"usernamePrefix\": \"\",\n    \"groupsClaim\": \"\",\n    \"groupsPrefix\": \"\",\n    \"requiredClaims\": \"\"\n  },\n  \"tags\": {},\n  \"clientRequestToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/clusters/:name/identity-provider-configs/associate")
  .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/clusters/:name/identity-provider-configs/associate',
  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({
  oidc: {
    identityProviderConfigName: '',
    issuerUrl: '',
    clientId: '',
    usernameClaim: '',
    usernamePrefix: '',
    groupsClaim: '',
    groupsPrefix: '',
    requiredClaims: ''
  },
  tags: {},
  clientRequestToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/identity-provider-configs/associate',
  headers: {'content-type': 'application/json'},
  body: {
    oidc: {
      identityProviderConfigName: '',
      issuerUrl: '',
      clientId: '',
      usernameClaim: '',
      usernamePrefix: '',
      groupsClaim: '',
      groupsPrefix: '',
      requiredClaims: ''
    },
    tags: {},
    clientRequestToken: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/clusters/:name/identity-provider-configs/associate');

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

req.type('json');
req.send({
  oidc: {
    identityProviderConfigName: '',
    issuerUrl: '',
    clientId: '',
    usernameClaim: '',
    usernamePrefix: '',
    groupsClaim: '',
    groupsPrefix: '',
    requiredClaims: ''
  },
  tags: {},
  clientRequestToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/identity-provider-configs/associate',
  headers: {'content-type': 'application/json'},
  data: {
    oidc: {
      identityProviderConfigName: '',
      issuerUrl: '',
      clientId: '',
      usernameClaim: '',
      usernamePrefix: '',
      groupsClaim: '',
      groupsPrefix: '',
      requiredClaims: ''
    },
    tags: {},
    clientRequestToken: ''
  }
};

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

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

const url = '{{baseUrl}}/clusters/:name/identity-provider-configs/associate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"oidc":{"identityProviderConfigName":"","issuerUrl":"","clientId":"","usernameClaim":"","usernamePrefix":"","groupsClaim":"","groupsPrefix":"","requiredClaims":""},"tags":{},"clientRequestToken":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"oidc": @{ @"identityProviderConfigName": @"", @"issuerUrl": @"", @"clientId": @"", @"usernameClaim": @"", @"usernamePrefix": @"", @"groupsClaim": @"", @"groupsPrefix": @"", @"requiredClaims": @"" },
                              @"tags": @{  },
                              @"clientRequestToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/clusters/:name/identity-provider-configs/associate"]
                                                       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}}/clusters/:name/identity-provider-configs/associate" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"oidc\": {\n    \"identityProviderConfigName\": \"\",\n    \"issuerUrl\": \"\",\n    \"clientId\": \"\",\n    \"usernameClaim\": \"\",\n    \"usernamePrefix\": \"\",\n    \"groupsClaim\": \"\",\n    \"groupsPrefix\": \"\",\n    \"requiredClaims\": \"\"\n  },\n  \"tags\": {},\n  \"clientRequestToken\": \"\"\n}" in

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

 "{{baseUrl}}/clusters/:name/identity-provider-configs/associate",
  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([
    'oidc' => [
        'identityProviderConfigName' => '',
        'issuerUrl' => '',
        'clientId' => '',
        'usernameClaim' => '',
        'usernamePrefix' => '',
        'groupsClaim' => '',
        'groupsPrefix' => '',
        'requiredClaims' => ''
    ],
    'tags' => [
        
    ],
    'clientRequestToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/clusters/:name/identity-provider-configs/associate', [
  'body' => '{
  "oidc": {
    "identityProviderConfigName": "",
    "issuerUrl": "",
    "clientId": "",
    "usernameClaim": "",
    "usernamePrefix": "",
    "groupsClaim": "",
    "groupsPrefix": "",
    "requiredClaims": ""
  },
  "tags": {},
  "clientRequestToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/clusters/:name/identity-provider-configs/associate');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'oidc' => [
    'identityProviderConfigName' => '',
    'issuerUrl' => '',
    'clientId' => '',
    'usernameClaim' => '',
    'usernamePrefix' => '',
    'groupsClaim' => '',
    'groupsPrefix' => '',
    'requiredClaims' => ''
  ],
  'tags' => [
    
  ],
  'clientRequestToken' => ''
]));

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

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

append(json_encode([
  'oidc' => [
    'identityProviderConfigName' => '',
    'issuerUrl' => '',
    'clientId' => '',
    'usernameClaim' => '',
    'usernamePrefix' => '',
    'groupsClaim' => '',
    'groupsPrefix' => '',
    'requiredClaims' => ''
  ],
  'tags' => [
    
  ],
  'clientRequestToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/clusters/:name/identity-provider-configs/associate');
$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}}/clusters/:name/identity-provider-configs/associate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "oidc": {
    "identityProviderConfigName": "",
    "issuerUrl": "",
    "clientId": "",
    "usernameClaim": "",
    "usernamePrefix": "",
    "groupsClaim": "",
    "groupsPrefix": "",
    "requiredClaims": ""
  },
  "tags": {},
  "clientRequestToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/clusters/:name/identity-provider-configs/associate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "oidc": {
    "identityProviderConfigName": "",
    "issuerUrl": "",
    "clientId": "",
    "usernameClaim": "",
    "usernamePrefix": "",
    "groupsClaim": "",
    "groupsPrefix": "",
    "requiredClaims": ""
  },
  "tags": {},
  "clientRequestToken": ""
}'

import http.client

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

payload = "{\n  \"oidc\": {\n    \"identityProviderConfigName\": \"\",\n    \"issuerUrl\": \"\",\n    \"clientId\": \"\",\n    \"usernameClaim\": \"\",\n    \"usernamePrefix\": \"\",\n    \"groupsClaim\": \"\",\n    \"groupsPrefix\": \"\",\n    \"requiredClaims\": \"\"\n  },\n  \"tags\": {},\n  \"clientRequestToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/clusters/:name/identity-provider-configs/associate", payload, headers)

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

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

import requests

url = "{{baseUrl}}/clusters/:name/identity-provider-configs/associate"

payload = {
    "oidc": {
        "identityProviderConfigName": "",
        "issuerUrl": "",
        "clientId": "",
        "usernameClaim": "",
        "usernamePrefix": "",
        "groupsClaim": "",
        "groupsPrefix": "",
        "requiredClaims": ""
    },
    "tags": {},
    "clientRequestToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/clusters/:name/identity-provider-configs/associate"

payload <- "{\n  \"oidc\": {\n    \"identityProviderConfigName\": \"\",\n    \"issuerUrl\": \"\",\n    \"clientId\": \"\",\n    \"usernameClaim\": \"\",\n    \"usernamePrefix\": \"\",\n    \"groupsClaim\": \"\",\n    \"groupsPrefix\": \"\",\n    \"requiredClaims\": \"\"\n  },\n  \"tags\": {},\n  \"clientRequestToken\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clusters/:name/identity-provider-configs/associate")

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  \"oidc\": {\n    \"identityProviderConfigName\": \"\",\n    \"issuerUrl\": \"\",\n    \"clientId\": \"\",\n    \"usernameClaim\": \"\",\n    \"usernamePrefix\": \"\",\n    \"groupsClaim\": \"\",\n    \"groupsPrefix\": \"\",\n    \"requiredClaims\": \"\"\n  },\n  \"tags\": {},\n  \"clientRequestToken\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/clusters/:name/identity-provider-configs/associate') do |req|
  req.body = "{\n  \"oidc\": {\n    \"identityProviderConfigName\": \"\",\n    \"issuerUrl\": \"\",\n    \"clientId\": \"\",\n    \"usernameClaim\": \"\",\n    \"usernamePrefix\": \"\",\n    \"groupsClaim\": \"\",\n    \"groupsPrefix\": \"\",\n    \"requiredClaims\": \"\"\n  },\n  \"tags\": {},\n  \"clientRequestToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/clusters/:name/identity-provider-configs/associate";

    let payload = json!({
        "oidc": json!({
            "identityProviderConfigName": "",
            "issuerUrl": "",
            "clientId": "",
            "usernameClaim": "",
            "usernamePrefix": "",
            "groupsClaim": "",
            "groupsPrefix": "",
            "requiredClaims": ""
        }),
        "tags": json!({}),
        "clientRequestToken": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "oidc": {
    "identityProviderConfigName": "",
    "issuerUrl": "",
    "clientId": "",
    "usernameClaim": "",
    "usernamePrefix": "",
    "groupsClaim": "",
    "groupsPrefix": "",
    "requiredClaims": ""
  },
  "tags": {},
  "clientRequestToken": ""
}' |  \
  http POST {{baseUrl}}/clusters/:name/identity-provider-configs/associate \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "oidc": {\n    "identityProviderConfigName": "",\n    "issuerUrl": "",\n    "clientId": "",\n    "usernameClaim": "",\n    "usernamePrefix": "",\n    "groupsClaim": "",\n    "groupsPrefix": "",\n    "requiredClaims": ""\n  },\n  "tags": {},\n  "clientRequestToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/clusters/:name/identity-provider-configs/associate

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "oidc": [
    "identityProviderConfigName": "",
    "issuerUrl": "",
    "clientId": "",
    "usernameClaim": "",
    "usernamePrefix": "",
    "groupsClaim": "",
    "groupsPrefix": "",
    "requiredClaims": ""
  ],
  "tags": [],
  "clientRequestToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clusters/:name/identity-provider-configs/associate")! 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}}/clusters/:name/addons");

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  \"addonName\": \"\",\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"configurationValues\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/clusters/:name/addons" {:content-type :json
                                                                  :form-params {:addonName ""
                                                                                :addonVersion ""
                                                                                :serviceAccountRoleArn ""
                                                                                :resolveConflicts ""
                                                                                :clientRequestToken ""
                                                                                :tags {}
                                                                                :configurationValues ""}})

require "http/client"

url = "{{baseUrl}}/clusters/:name/addons"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"addonName\": \"\",\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"configurationValues\": \"\"\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}}/clusters/:name/addons"),
    Content = new StringContent("{\n  \"addonName\": \"\",\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"configurationValues\": \"\"\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}}/clusters/:name/addons");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"addonName\": \"\",\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"configurationValues\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/clusters/:name/addons"

	payload := strings.NewReader("{\n  \"addonName\": \"\",\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"configurationValues\": \"\"\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/clusters/:name/addons HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 171

{
  "addonName": "",
  "addonVersion": "",
  "serviceAccountRoleArn": "",
  "resolveConflicts": "",
  "clientRequestToken": "",
  "tags": {},
  "configurationValues": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/clusters/:name/addons")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"addonName\": \"\",\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"configurationValues\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clusters/:name/addons"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"addonName\": \"\",\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"configurationValues\": \"\"\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  \"addonName\": \"\",\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"configurationValues\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/clusters/:name/addons")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/clusters/:name/addons")
  .header("content-type", "application/json")
  .body("{\n  \"addonName\": \"\",\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"configurationValues\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  addonName: '',
  addonVersion: '',
  serviceAccountRoleArn: '',
  resolveConflicts: '',
  clientRequestToken: '',
  tags: {},
  configurationValues: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/addons',
  headers: {'content-type': 'application/json'},
  data: {
    addonName: '',
    addonVersion: '',
    serviceAccountRoleArn: '',
    resolveConflicts: '',
    clientRequestToken: '',
    tags: {},
    configurationValues: ''
  }
};

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

const url = '{{baseUrl}}/clusters/:name/addons';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"addonName":"","addonVersion":"","serviceAccountRoleArn":"","resolveConflicts":"","clientRequestToken":"","tags":{},"configurationValues":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/clusters/:name/addons',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "addonName": "",\n  "addonVersion": "",\n  "serviceAccountRoleArn": "",\n  "resolveConflicts": "",\n  "clientRequestToken": "",\n  "tags": {},\n  "configurationValues": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"addonName\": \"\",\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"configurationValues\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/clusters/:name/addons")
  .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/clusters/:name/addons',
  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({
  addonName: '',
  addonVersion: '',
  serviceAccountRoleArn: '',
  resolveConflicts: '',
  clientRequestToken: '',
  tags: {},
  configurationValues: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/addons',
  headers: {'content-type': 'application/json'},
  body: {
    addonName: '',
    addonVersion: '',
    serviceAccountRoleArn: '',
    resolveConflicts: '',
    clientRequestToken: '',
    tags: {},
    configurationValues: ''
  },
  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}}/clusters/:name/addons');

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

req.type('json');
req.send({
  addonName: '',
  addonVersion: '',
  serviceAccountRoleArn: '',
  resolveConflicts: '',
  clientRequestToken: '',
  tags: {},
  configurationValues: ''
});

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}}/clusters/:name/addons',
  headers: {'content-type': 'application/json'},
  data: {
    addonName: '',
    addonVersion: '',
    serviceAccountRoleArn: '',
    resolveConflicts: '',
    clientRequestToken: '',
    tags: {},
    configurationValues: ''
  }
};

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

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

const url = '{{baseUrl}}/clusters/:name/addons';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"addonName":"","addonVersion":"","serviceAccountRoleArn":"","resolveConflicts":"","clientRequestToken":"","tags":{},"configurationValues":""}'
};

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 = @{ @"addonName": @"",
                              @"addonVersion": @"",
                              @"serviceAccountRoleArn": @"",
                              @"resolveConflicts": @"",
                              @"clientRequestToken": @"",
                              @"tags": @{  },
                              @"configurationValues": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/clusters/:name/addons"]
                                                       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}}/clusters/:name/addons" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"addonName\": \"\",\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"configurationValues\": \"\"\n}" in

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

 "{{baseUrl}}/clusters/:name/addons",
  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([
    'addonName' => '',
    'addonVersion' => '',
    'serviceAccountRoleArn' => '',
    'resolveConflicts' => '',
    'clientRequestToken' => '',
    'tags' => [
        
    ],
    'configurationValues' => ''
  ]),
  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}}/clusters/:name/addons', [
  'body' => '{
  "addonName": "",
  "addonVersion": "",
  "serviceAccountRoleArn": "",
  "resolveConflicts": "",
  "clientRequestToken": "",
  "tags": {},
  "configurationValues": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'addonName' => '',
  'addonVersion' => '',
  'serviceAccountRoleArn' => '',
  'resolveConflicts' => '',
  'clientRequestToken' => '',
  'tags' => [
    
  ],
  'configurationValues' => ''
]));

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

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

append(json_encode([
  'addonName' => '',
  'addonVersion' => '',
  'serviceAccountRoleArn' => '',
  'resolveConflicts' => '',
  'clientRequestToken' => '',
  'tags' => [
    
  ],
  'configurationValues' => ''
]));
$request->setRequestUrl('{{baseUrl}}/clusters/:name/addons');
$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}}/clusters/:name/addons' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "addonName": "",
  "addonVersion": "",
  "serviceAccountRoleArn": "",
  "resolveConflicts": "",
  "clientRequestToken": "",
  "tags": {},
  "configurationValues": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/clusters/:name/addons' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "addonName": "",
  "addonVersion": "",
  "serviceAccountRoleArn": "",
  "resolveConflicts": "",
  "clientRequestToken": "",
  "tags": {},
  "configurationValues": ""
}'

import http.client

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

payload = "{\n  \"addonName\": \"\",\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"configurationValues\": \"\"\n}"

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

conn.request("POST", "/baseUrl/clusters/:name/addons", payload, headers)

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

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

import requests

url = "{{baseUrl}}/clusters/:name/addons"

payload = {
    "addonName": "",
    "addonVersion": "",
    "serviceAccountRoleArn": "",
    "resolveConflicts": "",
    "clientRequestToken": "",
    "tags": {},
    "configurationValues": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/clusters/:name/addons"

payload <- "{\n  \"addonName\": \"\",\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"configurationValues\": \"\"\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}}/clusters/:name/addons")

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  \"addonName\": \"\",\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"configurationValues\": \"\"\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/clusters/:name/addons') do |req|
  req.body = "{\n  \"addonName\": \"\",\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"configurationValues\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "addonName": "",
        "addonVersion": "",
        "serviceAccountRoleArn": "",
        "resolveConflicts": "",
        "clientRequestToken": "",
        "tags": json!({}),
        "configurationValues": ""
    });

    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 '{
  "addonName": "",
  "addonVersion": "",
  "serviceAccountRoleArn": "",
  "resolveConflicts": "",
  "clientRequestToken": "",
  "tags": {},
  "configurationValues": ""
}' |  \
  http POST {{baseUrl}}/clusters/:name/addons \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "addonName": "",\n  "addonVersion": "",\n  "serviceAccountRoleArn": "",\n  "resolveConflicts": "",\n  "clientRequestToken": "",\n  "tags": {},\n  "configurationValues": ""\n}' \
  --output-document \
  - {{baseUrl}}/clusters/:name/addons

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "addonName": "",
  "addonVersion": "",
  "serviceAccountRoleArn": "",
  "resolveConflicts": "",
  "clientRequestToken": "",
  "tags": [],
  "configurationValues": ""
] as [String : Any]

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

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\",\n  \"version\": \"\",\n  \"roleArn\": \"\",\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"kubernetesNetworkConfig\": {\n    \"serviceIpv4Cidr\": \"\",\n    \"ipFamily\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"outpostConfig\": {\n    \"outpostArns\": \"\",\n    \"controlPlaneInstanceType\": \"\",\n    \"controlPlanePlacement\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/clusters" {:content-type :json
                                                     :form-params {:name ""
                                                                   :version ""
                                                                   :roleArn ""
                                                                   :resourcesVpcConfig {:subnetIds ""
                                                                                        :securityGroupIds ""
                                                                                        :endpointPublicAccess ""
                                                                                        :endpointPrivateAccess ""
                                                                                        :publicAccessCidrs ""}
                                                                   :kubernetesNetworkConfig {:serviceIpv4Cidr ""
                                                                                             :ipFamily ""}
                                                                   :logging {:clusterLogging ""}
                                                                   :clientRequestToken ""
                                                                   :tags {}
                                                                   :encryptionConfig [{:resources ""
                                                                                       :provider ""}]
                                                                   :outpostConfig {:outpostArns ""
                                                                                   :controlPlaneInstanceType ""
                                                                                   :controlPlanePlacement ""}}})

require "http/client"

url = "{{baseUrl}}/clusters"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"version\": \"\",\n  \"roleArn\": \"\",\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"kubernetesNetworkConfig\": {\n    \"serviceIpv4Cidr\": \"\",\n    \"ipFamily\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"outpostConfig\": {\n    \"outpostArns\": \"\",\n    \"controlPlaneInstanceType\": \"\",\n    \"controlPlanePlacement\": \"\"\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}}/clusters"),
    Content = new StringContent("{\n  \"name\": \"\",\n  \"version\": \"\",\n  \"roleArn\": \"\",\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"kubernetesNetworkConfig\": {\n    \"serviceIpv4Cidr\": \"\",\n    \"ipFamily\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"outpostConfig\": {\n    \"outpostArns\": \"\",\n    \"controlPlaneInstanceType\": \"\",\n    \"controlPlanePlacement\": \"\"\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}}/clusters");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"version\": \"\",\n  \"roleArn\": \"\",\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"kubernetesNetworkConfig\": {\n    \"serviceIpv4Cidr\": \"\",\n    \"ipFamily\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"outpostConfig\": {\n    \"outpostArns\": \"\",\n    \"controlPlaneInstanceType\": \"\",\n    \"controlPlanePlacement\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"version\": \"\",\n  \"roleArn\": \"\",\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"kubernetesNetworkConfig\": {\n    \"serviceIpv4Cidr\": \"\",\n    \"ipFamily\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"outpostConfig\": {\n    \"outpostArns\": \"\",\n    \"controlPlaneInstanceType\": \"\",\n    \"controlPlanePlacement\": \"\"\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/clusters HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 594

{
  "name": "",
  "version": "",
  "roleArn": "",
  "resourcesVpcConfig": {
    "subnetIds": "",
    "securityGroupIds": "",
    "endpointPublicAccess": "",
    "endpointPrivateAccess": "",
    "publicAccessCidrs": ""
  },
  "kubernetesNetworkConfig": {
    "serviceIpv4Cidr": "",
    "ipFamily": ""
  },
  "logging": {
    "clusterLogging": ""
  },
  "clientRequestToken": "",
  "tags": {},
  "encryptionConfig": [
    {
      "resources": "",
      "provider": ""
    }
  ],
  "outpostConfig": {
    "outpostArns": "",
    "controlPlaneInstanceType": "",
    "controlPlanePlacement": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/clusters")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"version\": \"\",\n  \"roleArn\": \"\",\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"kubernetesNetworkConfig\": {\n    \"serviceIpv4Cidr\": \"\",\n    \"ipFamily\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"outpostConfig\": {\n    \"outpostArns\": \"\",\n    \"controlPlaneInstanceType\": \"\",\n    \"controlPlanePlacement\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clusters"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"version\": \"\",\n  \"roleArn\": \"\",\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"kubernetesNetworkConfig\": {\n    \"serviceIpv4Cidr\": \"\",\n    \"ipFamily\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"outpostConfig\": {\n    \"outpostArns\": \"\",\n    \"controlPlaneInstanceType\": \"\",\n    \"controlPlanePlacement\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"version\": \"\",\n  \"roleArn\": \"\",\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"kubernetesNetworkConfig\": {\n    \"serviceIpv4Cidr\": \"\",\n    \"ipFamily\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"outpostConfig\": {\n    \"outpostArns\": \"\",\n    \"controlPlaneInstanceType\": \"\",\n    \"controlPlanePlacement\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/clusters")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/clusters")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"version\": \"\",\n  \"roleArn\": \"\",\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"kubernetesNetworkConfig\": {\n    \"serviceIpv4Cidr\": \"\",\n    \"ipFamily\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"outpostConfig\": {\n    \"outpostArns\": \"\",\n    \"controlPlaneInstanceType\": \"\",\n    \"controlPlanePlacement\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  version: '',
  roleArn: '',
  resourcesVpcConfig: {
    subnetIds: '',
    securityGroupIds: '',
    endpointPublicAccess: '',
    endpointPrivateAccess: '',
    publicAccessCidrs: ''
  },
  kubernetesNetworkConfig: {
    serviceIpv4Cidr: '',
    ipFamily: ''
  },
  logging: {
    clusterLogging: ''
  },
  clientRequestToken: '',
  tags: {},
  encryptionConfig: [
    {
      resources: '',
      provider: ''
    }
  ],
  outpostConfig: {
    outpostArns: '',
    controlPlaneInstanceType: '',
    controlPlanePlacement: ''
  }
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    version: '',
    roleArn: '',
    resourcesVpcConfig: {
      subnetIds: '',
      securityGroupIds: '',
      endpointPublicAccess: '',
      endpointPrivateAccess: '',
      publicAccessCidrs: ''
    },
    kubernetesNetworkConfig: {serviceIpv4Cidr: '', ipFamily: ''},
    logging: {clusterLogging: ''},
    clientRequestToken: '',
    tags: {},
    encryptionConfig: [{resources: '', provider: ''}],
    outpostConfig: {outpostArns: '', controlPlaneInstanceType: '', controlPlanePlacement: ''}
  }
};

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

const url = '{{baseUrl}}/clusters';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","version":"","roleArn":"","resourcesVpcConfig":{"subnetIds":"","securityGroupIds":"","endpointPublicAccess":"","endpointPrivateAccess":"","publicAccessCidrs":""},"kubernetesNetworkConfig":{"serviceIpv4Cidr":"","ipFamily":""},"logging":{"clusterLogging":""},"clientRequestToken":"","tags":{},"encryptionConfig":[{"resources":"","provider":""}],"outpostConfig":{"outpostArns":"","controlPlaneInstanceType":"","controlPlanePlacement":""}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/clusters',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "version": "",\n  "roleArn": "",\n  "resourcesVpcConfig": {\n    "subnetIds": "",\n    "securityGroupIds": "",\n    "endpointPublicAccess": "",\n    "endpointPrivateAccess": "",\n    "publicAccessCidrs": ""\n  },\n  "kubernetesNetworkConfig": {\n    "serviceIpv4Cidr": "",\n    "ipFamily": ""\n  },\n  "logging": {\n    "clusterLogging": ""\n  },\n  "clientRequestToken": "",\n  "tags": {},\n  "encryptionConfig": [\n    {\n      "resources": "",\n      "provider": ""\n    }\n  ],\n  "outpostConfig": {\n    "outpostArns": "",\n    "controlPlaneInstanceType": "",\n    "controlPlanePlacement": ""\n  }\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"version\": \"\",\n  \"roleArn\": \"\",\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"kubernetesNetworkConfig\": {\n    \"serviceIpv4Cidr\": \"\",\n    \"ipFamily\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"outpostConfig\": {\n    \"outpostArns\": \"\",\n    \"controlPlaneInstanceType\": \"\",\n    \"controlPlanePlacement\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/clusters")
  .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/clusters',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({
  name: '',
  version: '',
  roleArn: '',
  resourcesVpcConfig: {
    subnetIds: '',
    securityGroupIds: '',
    endpointPublicAccess: '',
    endpointPrivateAccess: '',
    publicAccessCidrs: ''
  },
  kubernetesNetworkConfig: {serviceIpv4Cidr: '', ipFamily: ''},
  logging: {clusterLogging: ''},
  clientRequestToken: '',
  tags: {},
  encryptionConfig: [{resources: '', provider: ''}],
  outpostConfig: {outpostArns: '', controlPlaneInstanceType: '', controlPlanePlacement: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters',
  headers: {'content-type': 'application/json'},
  body: {
    name: '',
    version: '',
    roleArn: '',
    resourcesVpcConfig: {
      subnetIds: '',
      securityGroupIds: '',
      endpointPublicAccess: '',
      endpointPrivateAccess: '',
      publicAccessCidrs: ''
    },
    kubernetesNetworkConfig: {serviceIpv4Cidr: '', ipFamily: ''},
    logging: {clusterLogging: ''},
    clientRequestToken: '',
    tags: {},
    encryptionConfig: [{resources: '', provider: ''}],
    outpostConfig: {outpostArns: '', controlPlaneInstanceType: '', controlPlanePlacement: ''}
  },
  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}}/clusters');

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

req.type('json');
req.send({
  name: '',
  version: '',
  roleArn: '',
  resourcesVpcConfig: {
    subnetIds: '',
    securityGroupIds: '',
    endpointPublicAccess: '',
    endpointPrivateAccess: '',
    publicAccessCidrs: ''
  },
  kubernetesNetworkConfig: {
    serviceIpv4Cidr: '',
    ipFamily: ''
  },
  logging: {
    clusterLogging: ''
  },
  clientRequestToken: '',
  tags: {},
  encryptionConfig: [
    {
      resources: '',
      provider: ''
    }
  ],
  outpostConfig: {
    outpostArns: '',
    controlPlaneInstanceType: '',
    controlPlanePlacement: ''
  }
});

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}}/clusters',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    version: '',
    roleArn: '',
    resourcesVpcConfig: {
      subnetIds: '',
      securityGroupIds: '',
      endpointPublicAccess: '',
      endpointPrivateAccess: '',
      publicAccessCidrs: ''
    },
    kubernetesNetworkConfig: {serviceIpv4Cidr: '', ipFamily: ''},
    logging: {clusterLogging: ''},
    clientRequestToken: '',
    tags: {},
    encryptionConfig: [{resources: '', provider: ''}],
    outpostConfig: {outpostArns: '', controlPlaneInstanceType: '', controlPlanePlacement: ''}
  }
};

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

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

const url = '{{baseUrl}}/clusters';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","version":"","roleArn":"","resourcesVpcConfig":{"subnetIds":"","securityGroupIds":"","endpointPublicAccess":"","endpointPrivateAccess":"","publicAccessCidrs":""},"kubernetesNetworkConfig":{"serviceIpv4Cidr":"","ipFamily":""},"logging":{"clusterLogging":""},"clientRequestToken":"","tags":{},"encryptionConfig":[{"resources":"","provider":""}],"outpostConfig":{"outpostArns":"","controlPlaneInstanceType":"","controlPlanePlacement":""}}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"name": @"",
                              @"version": @"",
                              @"roleArn": @"",
                              @"resourcesVpcConfig": @{ @"subnetIds": @"", @"securityGroupIds": @"", @"endpointPublicAccess": @"", @"endpointPrivateAccess": @"", @"publicAccessCidrs": @"" },
                              @"kubernetesNetworkConfig": @{ @"serviceIpv4Cidr": @"", @"ipFamily": @"" },
                              @"logging": @{ @"clusterLogging": @"" },
                              @"clientRequestToken": @"",
                              @"tags": @{  },
                              @"encryptionConfig": @[ @{ @"resources": @"", @"provider": @"" } ],
                              @"outpostConfig": @{ @"outpostArns": @"", @"controlPlaneInstanceType": @"", @"controlPlanePlacement": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/clusters"]
                                                       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}}/clusters" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"version\": \"\",\n  \"roleArn\": \"\",\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"kubernetesNetworkConfig\": {\n    \"serviceIpv4Cidr\": \"\",\n    \"ipFamily\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"outpostConfig\": {\n    \"outpostArns\": \"\",\n    \"controlPlaneInstanceType\": \"\",\n    \"controlPlanePlacement\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/clusters",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => '',
    'version' => '',
    'roleArn' => '',
    'resourcesVpcConfig' => [
        'subnetIds' => '',
        'securityGroupIds' => '',
        'endpointPublicAccess' => '',
        'endpointPrivateAccess' => '',
        'publicAccessCidrs' => ''
    ],
    'kubernetesNetworkConfig' => [
        'serviceIpv4Cidr' => '',
        'ipFamily' => ''
    ],
    'logging' => [
        'clusterLogging' => ''
    ],
    'clientRequestToken' => '',
    'tags' => [
        
    ],
    'encryptionConfig' => [
        [
                'resources' => '',
                'provider' => ''
        ]
    ],
    'outpostConfig' => [
        'outpostArns' => '',
        'controlPlaneInstanceType' => '',
        'controlPlanePlacement' => ''
    ]
  ]),
  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}}/clusters', [
  'body' => '{
  "name": "",
  "version": "",
  "roleArn": "",
  "resourcesVpcConfig": {
    "subnetIds": "",
    "securityGroupIds": "",
    "endpointPublicAccess": "",
    "endpointPrivateAccess": "",
    "publicAccessCidrs": ""
  },
  "kubernetesNetworkConfig": {
    "serviceIpv4Cidr": "",
    "ipFamily": ""
  },
  "logging": {
    "clusterLogging": ""
  },
  "clientRequestToken": "",
  "tags": {},
  "encryptionConfig": [
    {
      "resources": "",
      "provider": ""
    }
  ],
  "outpostConfig": {
    "outpostArns": "",
    "controlPlaneInstanceType": "",
    "controlPlanePlacement": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'version' => '',
  'roleArn' => '',
  'resourcesVpcConfig' => [
    'subnetIds' => '',
    'securityGroupIds' => '',
    'endpointPublicAccess' => '',
    'endpointPrivateAccess' => '',
    'publicAccessCidrs' => ''
  ],
  'kubernetesNetworkConfig' => [
    'serviceIpv4Cidr' => '',
    'ipFamily' => ''
  ],
  'logging' => [
    'clusterLogging' => ''
  ],
  'clientRequestToken' => '',
  'tags' => [
    
  ],
  'encryptionConfig' => [
    [
        'resources' => '',
        'provider' => ''
    ]
  ],
  'outpostConfig' => [
    'outpostArns' => '',
    'controlPlaneInstanceType' => '',
    'controlPlanePlacement' => ''
  ]
]));

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

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

append(json_encode([
  'name' => '',
  'version' => '',
  'roleArn' => '',
  'resourcesVpcConfig' => [
    'subnetIds' => '',
    'securityGroupIds' => '',
    'endpointPublicAccess' => '',
    'endpointPrivateAccess' => '',
    'publicAccessCidrs' => ''
  ],
  'kubernetesNetworkConfig' => [
    'serviceIpv4Cidr' => '',
    'ipFamily' => ''
  ],
  'logging' => [
    'clusterLogging' => ''
  ],
  'clientRequestToken' => '',
  'tags' => [
    
  ],
  'encryptionConfig' => [
    [
        'resources' => '',
        'provider' => ''
    ]
  ],
  'outpostConfig' => [
    'outpostArns' => '',
    'controlPlaneInstanceType' => '',
    'controlPlanePlacement' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/clusters');
$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}}/clusters' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "version": "",
  "roleArn": "",
  "resourcesVpcConfig": {
    "subnetIds": "",
    "securityGroupIds": "",
    "endpointPublicAccess": "",
    "endpointPrivateAccess": "",
    "publicAccessCidrs": ""
  },
  "kubernetesNetworkConfig": {
    "serviceIpv4Cidr": "",
    "ipFamily": ""
  },
  "logging": {
    "clusterLogging": ""
  },
  "clientRequestToken": "",
  "tags": {},
  "encryptionConfig": [
    {
      "resources": "",
      "provider": ""
    }
  ],
  "outpostConfig": {
    "outpostArns": "",
    "controlPlaneInstanceType": "",
    "controlPlanePlacement": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/clusters' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "version": "",
  "roleArn": "",
  "resourcesVpcConfig": {
    "subnetIds": "",
    "securityGroupIds": "",
    "endpointPublicAccess": "",
    "endpointPrivateAccess": "",
    "publicAccessCidrs": ""
  },
  "kubernetesNetworkConfig": {
    "serviceIpv4Cidr": "",
    "ipFamily": ""
  },
  "logging": {
    "clusterLogging": ""
  },
  "clientRequestToken": "",
  "tags": {},
  "encryptionConfig": [
    {
      "resources": "",
      "provider": ""
    }
  ],
  "outpostConfig": {
    "outpostArns": "",
    "controlPlaneInstanceType": "",
    "controlPlanePlacement": ""
  }
}'

import http.client

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

payload = "{\n  \"name\": \"\",\n  \"version\": \"\",\n  \"roleArn\": \"\",\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"kubernetesNetworkConfig\": {\n    \"serviceIpv4Cidr\": \"\",\n    \"ipFamily\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"outpostConfig\": {\n    \"outpostArns\": \"\",\n    \"controlPlaneInstanceType\": \"\",\n    \"controlPlanePlacement\": \"\"\n  }\n}"

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

conn.request("POST", "/baseUrl/clusters", payload, headers)

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

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

import requests

url = "{{baseUrl}}/clusters"

payload = {
    "name": "",
    "version": "",
    "roleArn": "",
    "resourcesVpcConfig": {
        "subnetIds": "",
        "securityGroupIds": "",
        "endpointPublicAccess": "",
        "endpointPrivateAccess": "",
        "publicAccessCidrs": ""
    },
    "kubernetesNetworkConfig": {
        "serviceIpv4Cidr": "",
        "ipFamily": ""
    },
    "logging": { "clusterLogging": "" },
    "clientRequestToken": "",
    "tags": {},
    "encryptionConfig": [
        {
            "resources": "",
            "provider": ""
        }
    ],
    "outpostConfig": {
        "outpostArns": "",
        "controlPlaneInstanceType": "",
        "controlPlanePlacement": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"name\": \"\",\n  \"version\": \"\",\n  \"roleArn\": \"\",\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"kubernetesNetworkConfig\": {\n    \"serviceIpv4Cidr\": \"\",\n    \"ipFamily\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"outpostConfig\": {\n    \"outpostArns\": \"\",\n    \"controlPlaneInstanceType\": \"\",\n    \"controlPlanePlacement\": \"\"\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}}/clusters")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"version\": \"\",\n  \"roleArn\": \"\",\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"kubernetesNetworkConfig\": {\n    \"serviceIpv4Cidr\": \"\",\n    \"ipFamily\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"outpostConfig\": {\n    \"outpostArns\": \"\",\n    \"controlPlaneInstanceType\": \"\",\n    \"controlPlanePlacement\": \"\"\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/clusters') do |req|
  req.body = "{\n  \"name\": \"\",\n  \"version\": \"\",\n  \"roleArn\": \"\",\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"kubernetesNetworkConfig\": {\n    \"serviceIpv4Cidr\": \"\",\n    \"ipFamily\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {},\n  \"encryptionConfig\": [\n    {\n      \"resources\": \"\",\n      \"provider\": \"\"\n    }\n  ],\n  \"outpostConfig\": {\n    \"outpostArns\": \"\",\n    \"controlPlaneInstanceType\": \"\",\n    \"controlPlanePlacement\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "name": "",
        "version": "",
        "roleArn": "",
        "resourcesVpcConfig": json!({
            "subnetIds": "",
            "securityGroupIds": "",
            "endpointPublicAccess": "",
            "endpointPrivateAccess": "",
            "publicAccessCidrs": ""
        }),
        "kubernetesNetworkConfig": json!({
            "serviceIpv4Cidr": "",
            "ipFamily": ""
        }),
        "logging": json!({"clusterLogging": ""}),
        "clientRequestToken": "",
        "tags": json!({}),
        "encryptionConfig": (
            json!({
                "resources": "",
                "provider": ""
            })
        ),
        "outpostConfig": json!({
            "outpostArns": "",
            "controlPlaneInstanceType": "",
            "controlPlanePlacement": ""
        })
    });

    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 '{
  "name": "",
  "version": "",
  "roleArn": "",
  "resourcesVpcConfig": {
    "subnetIds": "",
    "securityGroupIds": "",
    "endpointPublicAccess": "",
    "endpointPrivateAccess": "",
    "publicAccessCidrs": ""
  },
  "kubernetesNetworkConfig": {
    "serviceIpv4Cidr": "",
    "ipFamily": ""
  },
  "logging": {
    "clusterLogging": ""
  },
  "clientRequestToken": "",
  "tags": {},
  "encryptionConfig": [
    {
      "resources": "",
      "provider": ""
    }
  ],
  "outpostConfig": {
    "outpostArns": "",
    "controlPlaneInstanceType": "",
    "controlPlanePlacement": ""
  }
}' |  \
  http POST {{baseUrl}}/clusters \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "version": "",\n  "roleArn": "",\n  "resourcesVpcConfig": {\n    "subnetIds": "",\n    "securityGroupIds": "",\n    "endpointPublicAccess": "",\n    "endpointPrivateAccess": "",\n    "publicAccessCidrs": ""\n  },\n  "kubernetesNetworkConfig": {\n    "serviceIpv4Cidr": "",\n    "ipFamily": ""\n  },\n  "logging": {\n    "clusterLogging": ""\n  },\n  "clientRequestToken": "",\n  "tags": {},\n  "encryptionConfig": [\n    {\n      "resources": "",\n      "provider": ""\n    }\n  ],\n  "outpostConfig": {\n    "outpostArns": "",\n    "controlPlaneInstanceType": "",\n    "controlPlanePlacement": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/clusters

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "name": "",
  "version": "",
  "roleArn": "",
  "resourcesVpcConfig": [
    "subnetIds": "",
    "securityGroupIds": "",
    "endpointPublicAccess": "",
    "endpointPrivateAccess": "",
    "publicAccessCidrs": ""
  ],
  "kubernetesNetworkConfig": [
    "serviceIpv4Cidr": "",
    "ipFamily": ""
  ],
  "logging": ["clusterLogging": ""],
  "clientRequestToken": "",
  "tags": [],
  "encryptionConfig": [
    [
      "resources": "",
      "provider": ""
    ]
  ],
  "outpostConfig": [
    "outpostArns": "",
    "controlPlaneInstanceType": "",
    "controlPlanePlacement": ""
  ]
] as [String : Any]

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

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"fargateProfileName\": \"\",\n  \"podExecutionRoleArn\": \"\",\n  \"subnets\": [],\n  \"selectors\": [\n    {\n      \"namespace\": \"\",\n      \"labels\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/clusters/:name/fargate-profiles" {:content-type :json
                                                                            :form-params {:fargateProfileName ""
                                                                                          :podExecutionRoleArn ""
                                                                                          :subnets []
                                                                                          :selectors [{:namespace ""
                                                                                                       :labels ""}]
                                                                                          :clientRequestToken ""
                                                                                          :tags {}}})

require "http/client"

url = "{{baseUrl}}/clusters/:name/fargate-profiles"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"fargateProfileName\": \"\",\n  \"podExecutionRoleArn\": \"\",\n  \"subnets\": [],\n  \"selectors\": [\n    {\n      \"namespace\": \"\",\n      \"labels\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/clusters/:name/fargate-profiles"),
    Content = new StringContent("{\n  \"fargateProfileName\": \"\",\n  \"podExecutionRoleArn\": \"\",\n  \"subnets\": [],\n  \"selectors\": [\n    {\n      \"namespace\": \"\",\n      \"labels\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/clusters/:name/fargate-profiles");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"fargateProfileName\": \"\",\n  \"podExecutionRoleArn\": \"\",\n  \"subnets\": [],\n  \"selectors\": [\n    {\n      \"namespace\": \"\",\n      \"labels\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/clusters/:name/fargate-profiles"

	payload := strings.NewReader("{\n  \"fargateProfileName\": \"\",\n  \"podExecutionRoleArn\": \"\",\n  \"subnets\": [],\n  \"selectors\": [\n    {\n      \"namespace\": \"\",\n      \"labels\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}")

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

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

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

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

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

}

POST /baseUrl/clusters/:name/fargate-profiles HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 194

{
  "fargateProfileName": "",
  "podExecutionRoleArn": "",
  "subnets": [],
  "selectors": [
    {
      "namespace": "",
      "labels": ""
    }
  ],
  "clientRequestToken": "",
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/clusters/:name/fargate-profiles")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"fargateProfileName\": \"\",\n  \"podExecutionRoleArn\": \"\",\n  \"subnets\": [],\n  \"selectors\": [\n    {\n      \"namespace\": \"\",\n      \"labels\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clusters/:name/fargate-profiles"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"fargateProfileName\": \"\",\n  \"podExecutionRoleArn\": \"\",\n  \"subnets\": [],\n  \"selectors\": [\n    {\n      \"namespace\": \"\",\n      \"labels\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"fargateProfileName\": \"\",\n  \"podExecutionRoleArn\": \"\",\n  \"subnets\": [],\n  \"selectors\": [\n    {\n      \"namespace\": \"\",\n      \"labels\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/clusters/:name/fargate-profiles")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/clusters/:name/fargate-profiles")
  .header("content-type", "application/json")
  .body("{\n  \"fargateProfileName\": \"\",\n  \"podExecutionRoleArn\": \"\",\n  \"subnets\": [],\n  \"selectors\": [\n    {\n      \"namespace\": \"\",\n      \"labels\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  fargateProfileName: '',
  podExecutionRoleArn: '',
  subnets: [],
  selectors: [
    {
      namespace: '',
      labels: ''
    }
  ],
  clientRequestToken: '',
  tags: {}
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/fargate-profiles',
  headers: {'content-type': 'application/json'},
  data: {
    fargateProfileName: '',
    podExecutionRoleArn: '',
    subnets: [],
    selectors: [{namespace: '', labels: ''}],
    clientRequestToken: '',
    tags: {}
  }
};

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

const url = '{{baseUrl}}/clusters/:name/fargate-profiles';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"fargateProfileName":"","podExecutionRoleArn":"","subnets":[],"selectors":[{"namespace":"","labels":""}],"clientRequestToken":"","tags":{}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/clusters/:name/fargate-profiles',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "fargateProfileName": "",\n  "podExecutionRoleArn": "",\n  "subnets": [],\n  "selectors": [\n    {\n      "namespace": "",\n      "labels": ""\n    }\n  ],\n  "clientRequestToken": "",\n  "tags": {}\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"fargateProfileName\": \"\",\n  \"podExecutionRoleArn\": \"\",\n  \"subnets\": [],\n  \"selectors\": [\n    {\n      \"namespace\": \"\",\n      \"labels\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/clusters/:name/fargate-profiles")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/clusters/:name/fargate-profiles',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({
  fargateProfileName: '',
  podExecutionRoleArn: '',
  subnets: [],
  selectors: [{namespace: '', labels: ''}],
  clientRequestToken: '',
  tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/fargate-profiles',
  headers: {'content-type': 'application/json'},
  body: {
    fargateProfileName: '',
    podExecutionRoleArn: '',
    subnets: [],
    selectors: [{namespace: '', labels: ''}],
    clientRequestToken: '',
    tags: {}
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/clusters/:name/fargate-profiles');

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

req.type('json');
req.send({
  fargateProfileName: '',
  podExecutionRoleArn: '',
  subnets: [],
  selectors: [
    {
      namespace: '',
      labels: ''
    }
  ],
  clientRequestToken: '',
  tags: {}
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/fargate-profiles',
  headers: {'content-type': 'application/json'},
  data: {
    fargateProfileName: '',
    podExecutionRoleArn: '',
    subnets: [],
    selectors: [{namespace: '', labels: ''}],
    clientRequestToken: '',
    tags: {}
  }
};

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

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

const url = '{{baseUrl}}/clusters/:name/fargate-profiles';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"fargateProfileName":"","podExecutionRoleArn":"","subnets":[],"selectors":[{"namespace":"","labels":""}],"clientRequestToken":"","tags":{}}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"fargateProfileName": @"",
                              @"podExecutionRoleArn": @"",
                              @"subnets": @[  ],
                              @"selectors": @[ @{ @"namespace": @"", @"labels": @"" } ],
                              @"clientRequestToken": @"",
                              @"tags": @{  } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/clusters/:name/fargate-profiles"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/clusters/:name/fargate-profiles" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"fargateProfileName\": \"\",\n  \"podExecutionRoleArn\": \"\",\n  \"subnets\": [],\n  \"selectors\": [\n    {\n      \"namespace\": \"\",\n      \"labels\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}" in

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

 "{{baseUrl}}/clusters/:name/fargate-profiles",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'fargateProfileName' => '',
    'podExecutionRoleArn' => '',
    'subnets' => [
        
    ],
    'selectors' => [
        [
                'namespace' => '',
                'labels' => ''
        ]
    ],
    'clientRequestToken' => '',
    'tags' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/clusters/:name/fargate-profiles', [
  'body' => '{
  "fargateProfileName": "",
  "podExecutionRoleArn": "",
  "subnets": [],
  "selectors": [
    {
      "namespace": "",
      "labels": ""
    }
  ],
  "clientRequestToken": "",
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/clusters/:name/fargate-profiles');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'fargateProfileName' => '',
  'podExecutionRoleArn' => '',
  'subnets' => [
    
  ],
  'selectors' => [
    [
        'namespace' => '',
        'labels' => ''
    ]
  ],
  'clientRequestToken' => '',
  'tags' => [
    
  ]
]));

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

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

append(json_encode([
  'fargateProfileName' => '',
  'podExecutionRoleArn' => '',
  'subnets' => [
    
  ],
  'selectors' => [
    [
        'namespace' => '',
        'labels' => ''
    ]
  ],
  'clientRequestToken' => '',
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/clusters/:name/fargate-profiles');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/clusters/:name/fargate-profiles' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "fargateProfileName": "",
  "podExecutionRoleArn": "",
  "subnets": [],
  "selectors": [
    {
      "namespace": "",
      "labels": ""
    }
  ],
  "clientRequestToken": "",
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/clusters/:name/fargate-profiles' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "fargateProfileName": "",
  "podExecutionRoleArn": "",
  "subnets": [],
  "selectors": [
    {
      "namespace": "",
      "labels": ""
    }
  ],
  "clientRequestToken": "",
  "tags": {}
}'

import http.client

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

payload = "{\n  \"fargateProfileName\": \"\",\n  \"podExecutionRoleArn\": \"\",\n  \"subnets\": [],\n  \"selectors\": [\n    {\n      \"namespace\": \"\",\n      \"labels\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}"

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

conn.request("POST", "/baseUrl/clusters/:name/fargate-profiles", payload, headers)

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

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

import requests

url = "{{baseUrl}}/clusters/:name/fargate-profiles"

payload = {
    "fargateProfileName": "",
    "podExecutionRoleArn": "",
    "subnets": [],
    "selectors": [
        {
            "namespace": "",
            "labels": ""
        }
    ],
    "clientRequestToken": "",
    "tags": {}
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/clusters/:name/fargate-profiles"

payload <- "{\n  \"fargateProfileName\": \"\",\n  \"podExecutionRoleArn\": \"\",\n  \"subnets\": [],\n  \"selectors\": [\n    {\n      \"namespace\": \"\",\n      \"labels\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clusters/:name/fargate-profiles")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"fargateProfileName\": \"\",\n  \"podExecutionRoleArn\": \"\",\n  \"subnets\": [],\n  \"selectors\": [\n    {\n      \"namespace\": \"\",\n      \"labels\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/clusters/:name/fargate-profiles') do |req|
  req.body = "{\n  \"fargateProfileName\": \"\",\n  \"podExecutionRoleArn\": \"\",\n  \"subnets\": [],\n  \"selectors\": [\n    {\n      \"namespace\": \"\",\n      \"labels\": \"\"\n    }\n  ],\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "fargateProfileName": "",
        "podExecutionRoleArn": "",
        "subnets": (),
        "selectors": (
            json!({
                "namespace": "",
                "labels": ""
            })
        ),
        "clientRequestToken": "",
        "tags": json!({})
    });

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

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

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

    dbg!(results);
}

echo '{
  "fargateProfileName": "",
  "podExecutionRoleArn": "",
  "subnets": [],
  "selectors": [
    {
      "namespace": "",
      "labels": ""
    }
  ],
  "clientRequestToken": "",
  "tags": {}
}' |  \
  http POST {{baseUrl}}/clusters/:name/fargate-profiles \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "fargateProfileName": "",\n  "podExecutionRoleArn": "",\n  "subnets": [],\n  "selectors": [\n    {\n      "namespace": "",\n      "labels": ""\n    }\n  ],\n  "clientRequestToken": "",\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/clusters/:name/fargate-profiles

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "fargateProfileName": "",
  "podExecutionRoleArn": "",
  "subnets": [],
  "selectors": [
    [
      "namespace": "",
      "labels": ""
    ]
  ],
  "clientRequestToken": "",
  "tags": []
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/clusters/:name/node-groups");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"nodegroupName\": \"\",\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"diskSize\": 0,\n  \"subnets\": [],\n  \"instanceTypes\": [],\n  \"amiType\": \"\",\n  \"remoteAccess\": {\n    \"ec2SshKey\": \"\",\n    \"sourceSecurityGroups\": \"\"\n  },\n  \"nodeRole\": \"\",\n  \"labels\": {},\n  \"taints\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\",\n      \"effect\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"clientRequestToken\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"capacityType\": \"\",\n  \"version\": \"\",\n  \"releaseVersion\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/clusters/:name/node-groups" {:content-type :json
                                                                       :form-params {:nodegroupName ""
                                                                                     :scalingConfig {:minSize ""
                                                                                                     :maxSize ""
                                                                                                     :desiredSize ""}
                                                                                     :diskSize 0
                                                                                     :subnets []
                                                                                     :instanceTypes []
                                                                                     :amiType ""
                                                                                     :remoteAccess {:ec2SshKey ""
                                                                                                    :sourceSecurityGroups ""}
                                                                                     :nodeRole ""
                                                                                     :labels {}
                                                                                     :taints [{:key ""
                                                                                               :value ""
                                                                                               :effect ""}]
                                                                                     :tags {}
                                                                                     :clientRequestToken ""
                                                                                     :launchTemplate {:name ""
                                                                                                      :version ""
                                                                                                      :id ""}
                                                                                     :updateConfig {:maxUnavailable ""
                                                                                                    :maxUnavailablePercentage ""}
                                                                                     :capacityType ""
                                                                                     :version ""
                                                                                     :releaseVersion ""}})

require "http/client"

url = "{{baseUrl}}/clusters/:name/node-groups"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"nodegroupName\": \"\",\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"diskSize\": 0,\n  \"subnets\": [],\n  \"instanceTypes\": [],\n  \"amiType\": \"\",\n  \"remoteAccess\": {\n    \"ec2SshKey\": \"\",\n    \"sourceSecurityGroups\": \"\"\n  },\n  \"nodeRole\": \"\",\n  \"labels\": {},\n  \"taints\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\",\n      \"effect\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"clientRequestToken\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"capacityType\": \"\",\n  \"version\": \"\",\n  \"releaseVersion\": \"\"\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}}/clusters/:name/node-groups"),
    Content = new StringContent("{\n  \"nodegroupName\": \"\",\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"diskSize\": 0,\n  \"subnets\": [],\n  \"instanceTypes\": [],\n  \"amiType\": \"\",\n  \"remoteAccess\": {\n    \"ec2SshKey\": \"\",\n    \"sourceSecurityGroups\": \"\"\n  },\n  \"nodeRole\": \"\",\n  \"labels\": {},\n  \"taints\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\",\n      \"effect\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"clientRequestToken\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"capacityType\": \"\",\n  \"version\": \"\",\n  \"releaseVersion\": \"\"\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}}/clusters/:name/node-groups");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"nodegroupName\": \"\",\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"diskSize\": 0,\n  \"subnets\": [],\n  \"instanceTypes\": [],\n  \"amiType\": \"\",\n  \"remoteAccess\": {\n    \"ec2SshKey\": \"\",\n    \"sourceSecurityGroups\": \"\"\n  },\n  \"nodeRole\": \"\",\n  \"labels\": {},\n  \"taints\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\",\n      \"effect\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"clientRequestToken\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"capacityType\": \"\",\n  \"version\": \"\",\n  \"releaseVersion\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/clusters/:name/node-groups"

	payload := strings.NewReader("{\n  \"nodegroupName\": \"\",\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"diskSize\": 0,\n  \"subnets\": [],\n  \"instanceTypes\": [],\n  \"amiType\": \"\",\n  \"remoteAccess\": {\n    \"ec2SshKey\": \"\",\n    \"sourceSecurityGroups\": \"\"\n  },\n  \"nodeRole\": \"\",\n  \"labels\": {},\n  \"taints\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\",\n      \"effect\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"clientRequestToken\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"capacityType\": \"\",\n  \"version\": \"\",\n  \"releaseVersion\": \"\"\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/clusters/:name/node-groups HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 648

{
  "nodegroupName": "",
  "scalingConfig": {
    "minSize": "",
    "maxSize": "",
    "desiredSize": ""
  },
  "diskSize": 0,
  "subnets": [],
  "instanceTypes": [],
  "amiType": "",
  "remoteAccess": {
    "ec2SshKey": "",
    "sourceSecurityGroups": ""
  },
  "nodeRole": "",
  "labels": {},
  "taints": [
    {
      "key": "",
      "value": "",
      "effect": ""
    }
  ],
  "tags": {},
  "clientRequestToken": "",
  "launchTemplate": {
    "name": "",
    "version": "",
    "id": ""
  },
  "updateConfig": {
    "maxUnavailable": "",
    "maxUnavailablePercentage": ""
  },
  "capacityType": "",
  "version": "",
  "releaseVersion": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/clusters/:name/node-groups")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"nodegroupName\": \"\",\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"diskSize\": 0,\n  \"subnets\": [],\n  \"instanceTypes\": [],\n  \"amiType\": \"\",\n  \"remoteAccess\": {\n    \"ec2SshKey\": \"\",\n    \"sourceSecurityGroups\": \"\"\n  },\n  \"nodeRole\": \"\",\n  \"labels\": {},\n  \"taints\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\",\n      \"effect\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"clientRequestToken\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"capacityType\": \"\",\n  \"version\": \"\",\n  \"releaseVersion\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clusters/:name/node-groups"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"nodegroupName\": \"\",\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"diskSize\": 0,\n  \"subnets\": [],\n  \"instanceTypes\": [],\n  \"amiType\": \"\",\n  \"remoteAccess\": {\n    \"ec2SshKey\": \"\",\n    \"sourceSecurityGroups\": \"\"\n  },\n  \"nodeRole\": \"\",\n  \"labels\": {},\n  \"taints\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\",\n      \"effect\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"clientRequestToken\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"capacityType\": \"\",\n  \"version\": \"\",\n  \"releaseVersion\": \"\"\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  \"nodegroupName\": \"\",\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"diskSize\": 0,\n  \"subnets\": [],\n  \"instanceTypes\": [],\n  \"amiType\": \"\",\n  \"remoteAccess\": {\n    \"ec2SshKey\": \"\",\n    \"sourceSecurityGroups\": \"\"\n  },\n  \"nodeRole\": \"\",\n  \"labels\": {},\n  \"taints\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\",\n      \"effect\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"clientRequestToken\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"capacityType\": \"\",\n  \"version\": \"\",\n  \"releaseVersion\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/clusters/:name/node-groups")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/clusters/:name/node-groups")
  .header("content-type", "application/json")
  .body("{\n  \"nodegroupName\": \"\",\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"diskSize\": 0,\n  \"subnets\": [],\n  \"instanceTypes\": [],\n  \"amiType\": \"\",\n  \"remoteAccess\": {\n    \"ec2SshKey\": \"\",\n    \"sourceSecurityGroups\": \"\"\n  },\n  \"nodeRole\": \"\",\n  \"labels\": {},\n  \"taints\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\",\n      \"effect\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"clientRequestToken\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"capacityType\": \"\",\n  \"version\": \"\",\n  \"releaseVersion\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  nodegroupName: '',
  scalingConfig: {
    minSize: '',
    maxSize: '',
    desiredSize: ''
  },
  diskSize: 0,
  subnets: [],
  instanceTypes: [],
  amiType: '',
  remoteAccess: {
    ec2SshKey: '',
    sourceSecurityGroups: ''
  },
  nodeRole: '',
  labels: {},
  taints: [
    {
      key: '',
      value: '',
      effect: ''
    }
  ],
  tags: {},
  clientRequestToken: '',
  launchTemplate: {
    name: '',
    version: '',
    id: ''
  },
  updateConfig: {
    maxUnavailable: '',
    maxUnavailablePercentage: ''
  },
  capacityType: '',
  version: '',
  releaseVersion: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/node-groups',
  headers: {'content-type': 'application/json'},
  data: {
    nodegroupName: '',
    scalingConfig: {minSize: '', maxSize: '', desiredSize: ''},
    diskSize: 0,
    subnets: [],
    instanceTypes: [],
    amiType: '',
    remoteAccess: {ec2SshKey: '', sourceSecurityGroups: ''},
    nodeRole: '',
    labels: {},
    taints: [{key: '', value: '', effect: ''}],
    tags: {},
    clientRequestToken: '',
    launchTemplate: {name: '', version: '', id: ''},
    updateConfig: {maxUnavailable: '', maxUnavailablePercentage: ''},
    capacityType: '',
    version: '',
    releaseVersion: ''
  }
};

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

const url = '{{baseUrl}}/clusters/:name/node-groups';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"nodegroupName":"","scalingConfig":{"minSize":"","maxSize":"","desiredSize":""},"diskSize":0,"subnets":[],"instanceTypes":[],"amiType":"","remoteAccess":{"ec2SshKey":"","sourceSecurityGroups":""},"nodeRole":"","labels":{},"taints":[{"key":"","value":"","effect":""}],"tags":{},"clientRequestToken":"","launchTemplate":{"name":"","version":"","id":""},"updateConfig":{"maxUnavailable":"","maxUnavailablePercentage":""},"capacityType":"","version":"","releaseVersion":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/clusters/:name/node-groups',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "nodegroupName": "",\n  "scalingConfig": {\n    "minSize": "",\n    "maxSize": "",\n    "desiredSize": ""\n  },\n  "diskSize": 0,\n  "subnets": [],\n  "instanceTypes": [],\n  "amiType": "",\n  "remoteAccess": {\n    "ec2SshKey": "",\n    "sourceSecurityGroups": ""\n  },\n  "nodeRole": "",\n  "labels": {},\n  "taints": [\n    {\n      "key": "",\n      "value": "",\n      "effect": ""\n    }\n  ],\n  "tags": {},\n  "clientRequestToken": "",\n  "launchTemplate": {\n    "name": "",\n    "version": "",\n    "id": ""\n  },\n  "updateConfig": {\n    "maxUnavailable": "",\n    "maxUnavailablePercentage": ""\n  },\n  "capacityType": "",\n  "version": "",\n  "releaseVersion": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"nodegroupName\": \"\",\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"diskSize\": 0,\n  \"subnets\": [],\n  \"instanceTypes\": [],\n  \"amiType\": \"\",\n  \"remoteAccess\": {\n    \"ec2SshKey\": \"\",\n    \"sourceSecurityGroups\": \"\"\n  },\n  \"nodeRole\": \"\",\n  \"labels\": {},\n  \"taints\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\",\n      \"effect\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"clientRequestToken\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"capacityType\": \"\",\n  \"version\": \"\",\n  \"releaseVersion\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/clusters/:name/node-groups")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  nodegroupName: '',
  scalingConfig: {minSize: '', maxSize: '', desiredSize: ''},
  diskSize: 0,
  subnets: [],
  instanceTypes: [],
  amiType: '',
  remoteAccess: {ec2SshKey: '', sourceSecurityGroups: ''},
  nodeRole: '',
  labels: {},
  taints: [{key: '', value: '', effect: ''}],
  tags: {},
  clientRequestToken: '',
  launchTemplate: {name: '', version: '', id: ''},
  updateConfig: {maxUnavailable: '', maxUnavailablePercentage: ''},
  capacityType: '',
  version: '',
  releaseVersion: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/node-groups',
  headers: {'content-type': 'application/json'},
  body: {
    nodegroupName: '',
    scalingConfig: {minSize: '', maxSize: '', desiredSize: ''},
    diskSize: 0,
    subnets: [],
    instanceTypes: [],
    amiType: '',
    remoteAccess: {ec2SshKey: '', sourceSecurityGroups: ''},
    nodeRole: '',
    labels: {},
    taints: [{key: '', value: '', effect: ''}],
    tags: {},
    clientRequestToken: '',
    launchTemplate: {name: '', version: '', id: ''},
    updateConfig: {maxUnavailable: '', maxUnavailablePercentage: ''},
    capacityType: '',
    version: '',
    releaseVersion: ''
  },
  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}}/clusters/:name/node-groups');

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

req.type('json');
req.send({
  nodegroupName: '',
  scalingConfig: {
    minSize: '',
    maxSize: '',
    desiredSize: ''
  },
  diskSize: 0,
  subnets: [],
  instanceTypes: [],
  amiType: '',
  remoteAccess: {
    ec2SshKey: '',
    sourceSecurityGroups: ''
  },
  nodeRole: '',
  labels: {},
  taints: [
    {
      key: '',
      value: '',
      effect: ''
    }
  ],
  tags: {},
  clientRequestToken: '',
  launchTemplate: {
    name: '',
    version: '',
    id: ''
  },
  updateConfig: {
    maxUnavailable: '',
    maxUnavailablePercentage: ''
  },
  capacityType: '',
  version: '',
  releaseVersion: ''
});

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}}/clusters/:name/node-groups',
  headers: {'content-type': 'application/json'},
  data: {
    nodegroupName: '',
    scalingConfig: {minSize: '', maxSize: '', desiredSize: ''},
    diskSize: 0,
    subnets: [],
    instanceTypes: [],
    amiType: '',
    remoteAccess: {ec2SshKey: '', sourceSecurityGroups: ''},
    nodeRole: '',
    labels: {},
    taints: [{key: '', value: '', effect: ''}],
    tags: {},
    clientRequestToken: '',
    launchTemplate: {name: '', version: '', id: ''},
    updateConfig: {maxUnavailable: '', maxUnavailablePercentage: ''},
    capacityType: '',
    version: '',
    releaseVersion: ''
  }
};

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

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

const url = '{{baseUrl}}/clusters/:name/node-groups';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"nodegroupName":"","scalingConfig":{"minSize":"","maxSize":"","desiredSize":""},"diskSize":0,"subnets":[],"instanceTypes":[],"amiType":"","remoteAccess":{"ec2SshKey":"","sourceSecurityGroups":""},"nodeRole":"","labels":{},"taints":[{"key":"","value":"","effect":""}],"tags":{},"clientRequestToken":"","launchTemplate":{"name":"","version":"","id":""},"updateConfig":{"maxUnavailable":"","maxUnavailablePercentage":""},"capacityType":"","version":"","releaseVersion":""}'
};

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 = @{ @"nodegroupName": @"",
                              @"scalingConfig": @{ @"minSize": @"", @"maxSize": @"", @"desiredSize": @"" },
                              @"diskSize": @0,
                              @"subnets": @[  ],
                              @"instanceTypes": @[  ],
                              @"amiType": @"",
                              @"remoteAccess": @{ @"ec2SshKey": @"", @"sourceSecurityGroups": @"" },
                              @"nodeRole": @"",
                              @"labels": @{  },
                              @"taints": @[ @{ @"key": @"", @"value": @"", @"effect": @"" } ],
                              @"tags": @{  },
                              @"clientRequestToken": @"",
                              @"launchTemplate": @{ @"name": @"", @"version": @"", @"id": @"" },
                              @"updateConfig": @{ @"maxUnavailable": @"", @"maxUnavailablePercentage": @"" },
                              @"capacityType": @"",
                              @"version": @"",
                              @"releaseVersion": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/clusters/:name/node-groups" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"nodegroupName\": \"\",\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"diskSize\": 0,\n  \"subnets\": [],\n  \"instanceTypes\": [],\n  \"amiType\": \"\",\n  \"remoteAccess\": {\n    \"ec2SshKey\": \"\",\n    \"sourceSecurityGroups\": \"\"\n  },\n  \"nodeRole\": \"\",\n  \"labels\": {},\n  \"taints\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\",\n      \"effect\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"clientRequestToken\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"capacityType\": \"\",\n  \"version\": \"\",\n  \"releaseVersion\": \"\"\n}" in

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

 "{{baseUrl}}/clusters/:name/node-groups",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'nodegroupName' => '',
    'scalingConfig' => [
        'minSize' => '',
        'maxSize' => '',
        'desiredSize' => ''
    ],
    'diskSize' => 0,
    'subnets' => [
        
    ],
    'instanceTypes' => [
        
    ],
    'amiType' => '',
    'remoteAccess' => [
        'ec2SshKey' => '',
        'sourceSecurityGroups' => ''
    ],
    'nodeRole' => '',
    'labels' => [
        
    ],
    'taints' => [
        [
                'key' => '',
                'value' => '',
                'effect' => ''
        ]
    ],
    'tags' => [
        
    ],
    'clientRequestToken' => '',
    'launchTemplate' => [
        'name' => '',
        'version' => '',
        'id' => ''
    ],
    'updateConfig' => [
        'maxUnavailable' => '',
        'maxUnavailablePercentage' => ''
    ],
    'capacityType' => '',
    'version' => '',
    'releaseVersion' => ''
  ]),
  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}}/clusters/:name/node-groups', [
  'body' => '{
  "nodegroupName": "",
  "scalingConfig": {
    "minSize": "",
    "maxSize": "",
    "desiredSize": ""
  },
  "diskSize": 0,
  "subnets": [],
  "instanceTypes": [],
  "amiType": "",
  "remoteAccess": {
    "ec2SshKey": "",
    "sourceSecurityGroups": ""
  },
  "nodeRole": "",
  "labels": {},
  "taints": [
    {
      "key": "",
      "value": "",
      "effect": ""
    }
  ],
  "tags": {},
  "clientRequestToken": "",
  "launchTemplate": {
    "name": "",
    "version": "",
    "id": ""
  },
  "updateConfig": {
    "maxUnavailable": "",
    "maxUnavailablePercentage": ""
  },
  "capacityType": "",
  "version": "",
  "releaseVersion": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/clusters/:name/node-groups');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'nodegroupName' => '',
  'scalingConfig' => [
    'minSize' => '',
    'maxSize' => '',
    'desiredSize' => ''
  ],
  'diskSize' => 0,
  'subnets' => [
    
  ],
  'instanceTypes' => [
    
  ],
  'amiType' => '',
  'remoteAccess' => [
    'ec2SshKey' => '',
    'sourceSecurityGroups' => ''
  ],
  'nodeRole' => '',
  'labels' => [
    
  ],
  'taints' => [
    [
        'key' => '',
        'value' => '',
        'effect' => ''
    ]
  ],
  'tags' => [
    
  ],
  'clientRequestToken' => '',
  'launchTemplate' => [
    'name' => '',
    'version' => '',
    'id' => ''
  ],
  'updateConfig' => [
    'maxUnavailable' => '',
    'maxUnavailablePercentage' => ''
  ],
  'capacityType' => '',
  'version' => '',
  'releaseVersion' => ''
]));

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

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

append(json_encode([
  'nodegroupName' => '',
  'scalingConfig' => [
    'minSize' => '',
    'maxSize' => '',
    'desiredSize' => ''
  ],
  'diskSize' => 0,
  'subnets' => [
    
  ],
  'instanceTypes' => [
    
  ],
  'amiType' => '',
  'remoteAccess' => [
    'ec2SshKey' => '',
    'sourceSecurityGroups' => ''
  ],
  'nodeRole' => '',
  'labels' => [
    
  ],
  'taints' => [
    [
        'key' => '',
        'value' => '',
        'effect' => ''
    ]
  ],
  'tags' => [
    
  ],
  'clientRequestToken' => '',
  'launchTemplate' => [
    'name' => '',
    'version' => '',
    'id' => ''
  ],
  'updateConfig' => [
    'maxUnavailable' => '',
    'maxUnavailablePercentage' => ''
  ],
  'capacityType' => '',
  'version' => '',
  'releaseVersion' => ''
]));
$request->setRequestUrl('{{baseUrl}}/clusters/:name/node-groups');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/clusters/:name/node-groups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "nodegroupName": "",
  "scalingConfig": {
    "minSize": "",
    "maxSize": "",
    "desiredSize": ""
  },
  "diskSize": 0,
  "subnets": [],
  "instanceTypes": [],
  "amiType": "",
  "remoteAccess": {
    "ec2SshKey": "",
    "sourceSecurityGroups": ""
  },
  "nodeRole": "",
  "labels": {},
  "taints": [
    {
      "key": "",
      "value": "",
      "effect": ""
    }
  ],
  "tags": {},
  "clientRequestToken": "",
  "launchTemplate": {
    "name": "",
    "version": "",
    "id": ""
  },
  "updateConfig": {
    "maxUnavailable": "",
    "maxUnavailablePercentage": ""
  },
  "capacityType": "",
  "version": "",
  "releaseVersion": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/clusters/:name/node-groups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "nodegroupName": "",
  "scalingConfig": {
    "minSize": "",
    "maxSize": "",
    "desiredSize": ""
  },
  "diskSize": 0,
  "subnets": [],
  "instanceTypes": [],
  "amiType": "",
  "remoteAccess": {
    "ec2SshKey": "",
    "sourceSecurityGroups": ""
  },
  "nodeRole": "",
  "labels": {},
  "taints": [
    {
      "key": "",
      "value": "",
      "effect": ""
    }
  ],
  "tags": {},
  "clientRequestToken": "",
  "launchTemplate": {
    "name": "",
    "version": "",
    "id": ""
  },
  "updateConfig": {
    "maxUnavailable": "",
    "maxUnavailablePercentage": ""
  },
  "capacityType": "",
  "version": "",
  "releaseVersion": ""
}'

import http.client

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

payload = "{\n  \"nodegroupName\": \"\",\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"diskSize\": 0,\n  \"subnets\": [],\n  \"instanceTypes\": [],\n  \"amiType\": \"\",\n  \"remoteAccess\": {\n    \"ec2SshKey\": \"\",\n    \"sourceSecurityGroups\": \"\"\n  },\n  \"nodeRole\": \"\",\n  \"labels\": {},\n  \"taints\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\",\n      \"effect\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"clientRequestToken\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"capacityType\": \"\",\n  \"version\": \"\",\n  \"releaseVersion\": \"\"\n}"

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

conn.request("POST", "/baseUrl/clusters/:name/node-groups", payload, headers)

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

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

import requests

url = "{{baseUrl}}/clusters/:name/node-groups"

payload = {
    "nodegroupName": "",
    "scalingConfig": {
        "minSize": "",
        "maxSize": "",
        "desiredSize": ""
    },
    "diskSize": 0,
    "subnets": [],
    "instanceTypes": [],
    "amiType": "",
    "remoteAccess": {
        "ec2SshKey": "",
        "sourceSecurityGroups": ""
    },
    "nodeRole": "",
    "labels": {},
    "taints": [
        {
            "key": "",
            "value": "",
            "effect": ""
        }
    ],
    "tags": {},
    "clientRequestToken": "",
    "launchTemplate": {
        "name": "",
        "version": "",
        "id": ""
    },
    "updateConfig": {
        "maxUnavailable": "",
        "maxUnavailablePercentage": ""
    },
    "capacityType": "",
    "version": "",
    "releaseVersion": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/clusters/:name/node-groups"

payload <- "{\n  \"nodegroupName\": \"\",\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"diskSize\": 0,\n  \"subnets\": [],\n  \"instanceTypes\": [],\n  \"amiType\": \"\",\n  \"remoteAccess\": {\n    \"ec2SshKey\": \"\",\n    \"sourceSecurityGroups\": \"\"\n  },\n  \"nodeRole\": \"\",\n  \"labels\": {},\n  \"taints\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\",\n      \"effect\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"clientRequestToken\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"capacityType\": \"\",\n  \"version\": \"\",\n  \"releaseVersion\": \"\"\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}}/clusters/:name/node-groups")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"nodegroupName\": \"\",\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"diskSize\": 0,\n  \"subnets\": [],\n  \"instanceTypes\": [],\n  \"amiType\": \"\",\n  \"remoteAccess\": {\n    \"ec2SshKey\": \"\",\n    \"sourceSecurityGroups\": \"\"\n  },\n  \"nodeRole\": \"\",\n  \"labels\": {},\n  \"taints\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\",\n      \"effect\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"clientRequestToken\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"capacityType\": \"\",\n  \"version\": \"\",\n  \"releaseVersion\": \"\"\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/clusters/:name/node-groups') do |req|
  req.body = "{\n  \"nodegroupName\": \"\",\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"diskSize\": 0,\n  \"subnets\": [],\n  \"instanceTypes\": [],\n  \"amiType\": \"\",\n  \"remoteAccess\": {\n    \"ec2SshKey\": \"\",\n    \"sourceSecurityGroups\": \"\"\n  },\n  \"nodeRole\": \"\",\n  \"labels\": {},\n  \"taints\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\",\n      \"effect\": \"\"\n    }\n  ],\n  \"tags\": {},\n  \"clientRequestToken\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"capacityType\": \"\",\n  \"version\": \"\",\n  \"releaseVersion\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "nodegroupName": "",
        "scalingConfig": json!({
            "minSize": "",
            "maxSize": "",
            "desiredSize": ""
        }),
        "diskSize": 0,
        "subnets": (),
        "instanceTypes": (),
        "amiType": "",
        "remoteAccess": json!({
            "ec2SshKey": "",
            "sourceSecurityGroups": ""
        }),
        "nodeRole": "",
        "labels": json!({}),
        "taints": (
            json!({
                "key": "",
                "value": "",
                "effect": ""
            })
        ),
        "tags": json!({}),
        "clientRequestToken": "",
        "launchTemplate": json!({
            "name": "",
            "version": "",
            "id": ""
        }),
        "updateConfig": json!({
            "maxUnavailable": "",
            "maxUnavailablePercentage": ""
        }),
        "capacityType": "",
        "version": "",
        "releaseVersion": ""
    });

    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 '{
  "nodegroupName": "",
  "scalingConfig": {
    "minSize": "",
    "maxSize": "",
    "desiredSize": ""
  },
  "diskSize": 0,
  "subnets": [],
  "instanceTypes": [],
  "amiType": "",
  "remoteAccess": {
    "ec2SshKey": "",
    "sourceSecurityGroups": ""
  },
  "nodeRole": "",
  "labels": {},
  "taints": [
    {
      "key": "",
      "value": "",
      "effect": ""
    }
  ],
  "tags": {},
  "clientRequestToken": "",
  "launchTemplate": {
    "name": "",
    "version": "",
    "id": ""
  },
  "updateConfig": {
    "maxUnavailable": "",
    "maxUnavailablePercentage": ""
  },
  "capacityType": "",
  "version": "",
  "releaseVersion": ""
}' |  \
  http POST {{baseUrl}}/clusters/:name/node-groups \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "nodegroupName": "",\n  "scalingConfig": {\n    "minSize": "",\n    "maxSize": "",\n    "desiredSize": ""\n  },\n  "diskSize": 0,\n  "subnets": [],\n  "instanceTypes": [],\n  "amiType": "",\n  "remoteAccess": {\n    "ec2SshKey": "",\n    "sourceSecurityGroups": ""\n  },\n  "nodeRole": "",\n  "labels": {},\n  "taints": [\n    {\n      "key": "",\n      "value": "",\n      "effect": ""\n    }\n  ],\n  "tags": {},\n  "clientRequestToken": "",\n  "launchTemplate": {\n    "name": "",\n    "version": "",\n    "id": ""\n  },\n  "updateConfig": {\n    "maxUnavailable": "",\n    "maxUnavailablePercentage": ""\n  },\n  "capacityType": "",\n  "version": "",\n  "releaseVersion": ""\n}' \
  --output-document \
  - {{baseUrl}}/clusters/:name/node-groups

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "nodegroupName": "",
  "scalingConfig": [
    "minSize": "",
    "maxSize": "",
    "desiredSize": ""
  ],
  "diskSize": 0,
  "subnets": [],
  "instanceTypes": [],
  "amiType": "",
  "remoteAccess": [
    "ec2SshKey": "",
    "sourceSecurityGroups": ""
  ],
  "nodeRole": "",
  "labels": [],
  "taints": [
    [
      "key": "",
      "value": "",
      "effect": ""
    ]
  ],
  "tags": [],
  "clientRequestToken": "",
  "launchTemplate": [
    "name": "",
    "version": "",
    "id": ""
  ],
  "updateConfig": [
    "maxUnavailable": "",
    "maxUnavailablePercentage": ""
  ],
  "capacityType": "",
  "version": "",
  "releaseVersion": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/clusters/:name/addons/:addonName")

require "http/client"

url = "{{baseUrl}}/clusters/:name/addons/:addonName"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/clusters/:name/addons/:addonName"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/clusters/:name/addons/:addonName'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/clusters/:name/addons/:addonName")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/clusters/:name/addons/:addonName');

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}}/clusters/:name/addons/:addonName'
};

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

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

const url = '{{baseUrl}}/clusters/:name/addons/:addonName';
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}}/clusters/:name/addons/:addonName"]
                                                       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}}/clusters/:name/addons/:addonName" in

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

 "{{baseUrl}}/clusters/:name/addons/:addonName",
  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}}/clusters/:name/addons/:addonName');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("DELETE", "/baseUrl/clusters/:name/addons/:addonName")

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

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

import requests

url = "{{baseUrl}}/clusters/:name/addons/:addonName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/clusters/:name/addons/:addonName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clusters/:name/addons/:addonName")

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/clusters/:name/addons/:addonName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

    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}}/clusters/:name/addons/:addonName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/clusters/:name/addons/:addonName

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

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

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

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

package main

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

func main() {

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

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

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

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

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

}

DELETE /baseUrl/clusters/:name HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/clusters/:name")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/clusters/:name")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/clusters/:name');

xhr.send(data);

import axios from 'axios';

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

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

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

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/clusters/:name',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/clusters/:name")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/clusters/:name',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/clusters/:name');

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

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

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

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

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

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

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

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/clusters/:name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/clusters/:name" in

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

 "{{baseUrl}}/clusters/:name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/clusters/:name');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

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

response = requests.delete(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clusters/:name")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/clusters/:name') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

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

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

    dbg!(results);
}

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

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

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName")

require "http/client"

url = "{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName"

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

var client = new RestClient("{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName"

	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/clusters/:name/fargate-profiles/:fargateProfileName HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName');

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}}/clusters/:name/fargate-profiles/:fargateProfileName'
};

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

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

const url = '{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName';
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}}/clusters/:name/fargate-profiles/:fargateProfileName"]
                                                       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}}/clusters/:name/fargate-profiles/:fargateProfileName" in

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

 "{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName",
  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}}/clusters/:name/fargate-profiles/:fargateProfileName');

echo $response->getBody();

setUrl('{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/clusters/:name/fargate-profiles/:fargateProfileName")

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

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

import requests

url = "{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName")

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/clusters/:name/fargate-profiles/:fargateProfileName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

    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}}/clusters/:name/fargate-profiles/:fargateProfileName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName")! 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}}/clusters/:name/node-groups/:nodegroupName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName")

require "http/client"

url = "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName"

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

var client = new RestClient("{{baseUrl}}/clusters/:name/node-groups/:nodegroupName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName"

	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/clusters/:name/node-groups/:nodegroupName HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/clusters/:name/node-groups/:nodegroupName")
  .delete(null)
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName');

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}}/clusters/:name/node-groups/:nodegroupName'
};

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

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

const url = '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName';
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}}/clusters/:name/node-groups/:nodegroupName"]
                                                       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}}/clusters/:name/node-groups/:nodegroupName" in

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

 "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName",
  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}}/clusters/:name/node-groups/:nodegroupName');

echo $response->getBody();

setUrl('{{baseUrl}}/clusters/:name/node-groups/:nodegroupName');
$request->setMethod(HTTP_METH_DELETE);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/clusters/:name/node-groups/:nodegroupName")

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

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

import requests

url = "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clusters/:name/node-groups/:nodegroupName")

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/clusters/:name/node-groups/:nodegroupName') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName";

    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}}/clusters/:name/node-groups/:nodegroupName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/clusters/:name/node-groups/:nodegroupName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName")! 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}}/cluster-registrations/:name");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/cluster-registrations/:name")

require "http/client"

url = "{{baseUrl}}/cluster-registrations/:name"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/cluster-registrations/:name"

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

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

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

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

}

DELETE /baseUrl/cluster-registrations/:name HTTP/1.1
Host: example.com

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/cluster-registrations/:name"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/cluster-registrations/:name")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/cluster-registrations/:name")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/cluster-registrations/:name');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/cluster-registrations/:name'
};

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

const url = '{{baseUrl}}/cluster-registrations/:name';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/cluster-registrations/:name',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/cluster-registrations/:name")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/cluster-registrations/:name',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/cluster-registrations/:name'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/cluster-registrations/:name');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/cluster-registrations/:name'
};

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

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

const url = '{{baseUrl}}/cluster-registrations/:name';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/cluster-registrations/:name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/cluster-registrations/:name" in

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

 "{{baseUrl}}/cluster-registrations/:name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/cluster-registrations/:name');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("DELETE", "/baseUrl/cluster-registrations/:name")

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

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

import requests

url = "{{baseUrl}}/cluster-registrations/:name"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/cluster-registrations/:name"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/cluster-registrations/:name")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/cluster-registrations/:name') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

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

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/cluster-registrations/:name

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

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/clusters/:name/addons/:addonName")

require "http/client"

url = "{{baseUrl}}/clusters/:name/addons/:addonName"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/clusters/:name/addons/:addonName"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/clusters/:name/addons/:addonName'
};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/clusters/:name/addons/:addonName');

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}}/clusters/:name/addons/:addonName'
};

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

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

const url = '{{baseUrl}}/clusters/:name/addons/:addonName';
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}}/clusters/:name/addons/:addonName"]
                                                       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}}/clusters/:name/addons/:addonName" in

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

 "{{baseUrl}}/clusters/:name/addons/:addonName",
  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}}/clusters/:name/addons/:addonName');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/clusters/:name/addons/:addonName")

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

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

import requests

url = "{{baseUrl}}/clusters/:name/addons/:addonName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/clusters/:name/addons/:addonName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clusters/:name/addons/:addonName")

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/clusters/:name/addons/:addonName') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/clusters/:name/addons/:addonName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/clusters/:name/addons/:addonName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clusters/:name/addons/:addonName")! 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}}/addons/configuration-schemas?addonName=&addonVersion=#addonName&addonVersion");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/addons/configuration-schemas#addonName&addonVersion" {:query-params {:addonName ""
                                                                                                              :addonVersion ""}})

require "http/client"

url = "{{baseUrl}}/addons/configuration-schemas?addonName=&addonVersion=#addonName&addonVersion"

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}}/addons/configuration-schemas?addonName=&addonVersion=#addonName&addonVersion"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/addons/configuration-schemas?addonName=&addonVersion=#addonName&addonVersion");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/addons/configuration-schemas?addonName=&addonVersion=#addonName&addonVersion"

	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/addons/configuration-schemas?addonName=&addonVersion= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/addons/configuration-schemas?addonName=&addonVersion=#addonName&addonVersion")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/addons/configuration-schemas?addonName=&addonVersion=#addonName&addonVersion"))
    .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}}/addons/configuration-schemas?addonName=&addonVersion=#addonName&addonVersion")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/addons/configuration-schemas?addonName=&addonVersion=#addonName&addonVersion")
  .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}}/addons/configuration-schemas?addonName=&addonVersion=#addonName&addonVersion');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/addons/configuration-schemas#addonName&addonVersion',
  params: {addonName: '', addonVersion: ''}
};

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

const url = '{{baseUrl}}/addons/configuration-schemas?addonName=&addonVersion=#addonName&addonVersion';
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}}/addons/configuration-schemas?addonName=&addonVersion=#addonName&addonVersion',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/addons/configuration-schemas?addonName=&addonVersion=#addonName&addonVersion")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/addons/configuration-schemas?addonName=&addonVersion=',
  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}}/addons/configuration-schemas#addonName&addonVersion',
  qs: {addonName: '', addonVersion: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/addons/configuration-schemas#addonName&addonVersion');

req.query({
  addonName: '',
  addonVersion: ''
});

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}}/addons/configuration-schemas#addonName&addonVersion',
  params: {addonName: '', addonVersion: ''}
};

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

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

const url = '{{baseUrl}}/addons/configuration-schemas?addonName=&addonVersion=#addonName&addonVersion';
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}}/addons/configuration-schemas?addonName=&addonVersion=#addonName&addonVersion"]
                                                       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}}/addons/configuration-schemas?addonName=&addonVersion=#addonName&addonVersion" in

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

 "{{baseUrl}}/addons/configuration-schemas?addonName=&addonVersion=#addonName&addonVersion",
  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}}/addons/configuration-schemas?addonName=&addonVersion=#addonName&addonVersion');

echo $response->getBody();

setUrl('{{baseUrl}}/addons/configuration-schemas#addonName&addonVersion');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'addonName' => '',
  'addonVersion' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/addons/configuration-schemas#addonName&addonVersion');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'addonName' => '',
  'addonVersion' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/addons/configuration-schemas?addonName=&addonVersion=#addonName&addonVersion' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/addons/configuration-schemas?addonName=&addonVersion=#addonName&addonVersion' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/addons/configuration-schemas?addonName=&addonVersion=")

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

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

import requests

url = "{{baseUrl}}/addons/configuration-schemas#addonName&addonVersion"

querystring = {"addonName":"","addonVersion":""}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/addons/configuration-schemas#addonName&addonVersion"

queryString <- list(
  addonName = "",
  addonVersion = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/addons/configuration-schemas?addonName=&addonVersion=#addonName&addonVersion")

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/addons/configuration-schemas') do |req|
  req.params['addonName'] = ''
  req.params['addonVersion'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/addons/configuration-schemas#addonName&addonVersion";

    let querystring = [
        ("addonName", ""),
        ("addonVersion", ""),
    ];

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

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

    dbg!(results);
}

http GET '{{baseUrl}}/addons/configuration-schemas?addonName=&addonVersion=#addonName&addonVersion'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/addons/configuration-schemas?addonName=&addonVersion=#addonName&addonVersion'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/addons/configuration-schemas?addonName=&addonVersion=#addonName&addonVersion")! 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}}/addons/supported-versions");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/addons/supported-versions")

require "http/client"

url = "{{baseUrl}}/addons/supported-versions"

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

var client = new RestClient("{{baseUrl}}/addons/supported-versions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/addons/supported-versions"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/addons/supported-versions'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/addons/supported-versions")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/addons/supported-versions');

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}}/addons/supported-versions'};

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

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

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

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

 "{{baseUrl}}/addons/supported-versions",
  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}}/addons/supported-versions');

echo $response->getBody();

setUrl('{{baseUrl}}/addons/supported-versions');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/addons/supported-versions' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/addons/supported-versions' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/addons/supported-versions")

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

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

import requests

url = "{{baseUrl}}/addons/supported-versions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/addons/supported-versions"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/addons/supported-versions")

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/addons/supported-versions') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/addons/supported-versions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/addons/supported-versions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/addons/supported-versions")! 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}}/clusters/:name");

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

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

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

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

package main

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

func main() {

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

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

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

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

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

}

GET /baseUrl/clusters/:name HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/clusters/:name")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/clusters/:name")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/clusters/:name');

xhr.send(data);

import axios from 'axios';

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

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

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

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/clusters/:name',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/clusters/:name');

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

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

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

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

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

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

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

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/clusters/:name" in

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

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

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/clusters/:name');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clusters/:name")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/clusters/:name') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

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

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

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName")

require "http/client"

url = "{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName"

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

var client = new RestClient("{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName"

	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/clusters/:name/fargate-profiles/:fargateProfileName HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName');

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}}/clusters/:name/fargate-profiles/:fargateProfileName'
};

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

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

const url = '{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName';
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}}/clusters/:name/fargate-profiles/:fargateProfileName"]
                                                       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}}/clusters/:name/fargate-profiles/:fargateProfileName" in

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

 "{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName",
  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}}/clusters/:name/fargate-profiles/:fargateProfileName');

echo $response->getBody();

setUrl('{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/clusters/:name/fargate-profiles/:fargateProfileName")

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

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

import requests

url = "{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName")

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/clusters/:name/fargate-profiles/:fargateProfileName') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clusters/:name/fargate-profiles/:fargateProfileName")! 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}}/clusters/:name/identity-provider-configs/describe");

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  \"identityProviderConfig\": {\n    \"type\": \"\",\n    \"name\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/clusters/:name/identity-provider-configs/describe" {:content-type :json
                                                                                              :form-params {:identityProviderConfig {:type ""
                                                                                                                                     :name ""}}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/clusters/:name/identity-provider-configs/describe"

	payload := strings.NewReader("{\n  \"identityProviderConfig\": {\n    \"type\": \"\",\n    \"name\": \"\"\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/clusters/:name/identity-provider-configs/describe HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 68

{
  "identityProviderConfig": {
    "type": "",
    "name": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/clusters/:name/identity-provider-configs/describe")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"identityProviderConfig\": {\n    \"type\": \"\",\n    \"name\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/clusters/:name/identity-provider-configs/describe")
  .header("content-type", "application/json")
  .body("{\n  \"identityProviderConfig\": {\n    \"type\": \"\",\n    \"name\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  identityProviderConfig: {
    type: '',
    name: ''
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/clusters/:name/identity-provider-configs/describe');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/identity-provider-configs/describe',
  headers: {'content-type': 'application/json'},
  data: {identityProviderConfig: {type: '', name: ''}}
};

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

const url = '{{baseUrl}}/clusters/:name/identity-provider-configs/describe';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"identityProviderConfig":{"type":"","name":""}}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/clusters/:name/identity-provider-configs/describe',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "identityProviderConfig": {\n    "type": "",\n    "name": ""\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  \"identityProviderConfig\": {\n    \"type\": \"\",\n    \"name\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/clusters/:name/identity-provider-configs/describe")
  .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/clusters/:name/identity-provider-configs/describe',
  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({identityProviderConfig: {type: '', name: ''}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/identity-provider-configs/describe',
  headers: {'content-type': 'application/json'},
  body: {identityProviderConfig: {type: '', name: ''}},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/clusters/:name/identity-provider-configs/describe');

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

req.type('json');
req.send({
  identityProviderConfig: {
    type: '',
    name: ''
  }
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/identity-provider-configs/describe',
  headers: {'content-type': 'application/json'},
  data: {identityProviderConfig: {type: '', name: ''}}
};

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

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

const url = '{{baseUrl}}/clusters/:name/identity-provider-configs/describe';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"identityProviderConfig":{"type":"","name":""}}'
};

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

#import 

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

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

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

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

 "{{baseUrl}}/clusters/:name/identity-provider-configs/describe",
  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([
    'identityProviderConfig' => [
        'type' => '',
        'name' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/clusters/:name/identity-provider-configs/describe', [
  'body' => '{
  "identityProviderConfig": {
    "type": "",
    "name": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/clusters/:name/identity-provider-configs/describe');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'identityProviderConfig' => [
    'type' => '',
    'name' => ''
  ]
]));

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

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

append(json_encode([
  'identityProviderConfig' => [
    'type' => '',
    'name' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/clusters/:name/identity-provider-configs/describe');
$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}}/clusters/:name/identity-provider-configs/describe' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "identityProviderConfig": {
    "type": "",
    "name": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/clusters/:name/identity-provider-configs/describe' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "identityProviderConfig": {
    "type": "",
    "name": ""
  }
}'

import http.client

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

payload = "{\n  \"identityProviderConfig\": {\n    \"type\": \"\",\n    \"name\": \"\"\n  }\n}"

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

conn.request("POST", "/baseUrl/clusters/:name/identity-provider-configs/describe", payload, headers)

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

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

import requests

url = "{{baseUrl}}/clusters/:name/identity-provider-configs/describe"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/clusters/:name/identity-provider-configs/describe"

payload <- "{\n  \"identityProviderConfig\": {\n    \"type\": \"\",\n    \"name\": \"\"\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}}/clusters/:name/identity-provider-configs/describe")

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  \"identityProviderConfig\": {\n    \"type\": \"\",\n    \"name\": \"\"\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/clusters/:name/identity-provider-configs/describe') do |req|
  req.body = "{\n  \"identityProviderConfig\": {\n    \"type\": \"\",\n    \"name\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/clusters/:name/identity-provider-configs/describe";

    let payload = json!({"identityProviderConfig": json!({
            "type": "",
            "name": ""
        })});

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

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

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

    dbg!(results);
}

echo '{
  "identityProviderConfig": {
    "type": "",
    "name": ""
  }
}' |  \
  http POST {{baseUrl}}/clusters/:name/identity-provider-configs/describe \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "identityProviderConfig": {\n    "type": "",\n    "name": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/clusters/:name/identity-provider-configs/describe

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clusters/:name/identity-provider-configs/describe")! 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}}/clusters/:name/node-groups/:nodegroupName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName")

require "http/client"

url = "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName"

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

var client = new RestClient("{{baseUrl}}/clusters/:name/node-groups/:nodegroupName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName"

	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/clusters/:name/node-groups/:nodegroupName HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName'
};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/clusters/:name/node-groups/:nodegroupName")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName');

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}}/clusters/:name/node-groups/:nodegroupName'
};

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

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

const url = '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName';
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}}/clusters/:name/node-groups/:nodegroupName"]
                                                       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}}/clusters/:name/node-groups/:nodegroupName" in

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

 "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName",
  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}}/clusters/:name/node-groups/:nodegroupName');

echo $response->getBody();

setUrl('{{baseUrl}}/clusters/:name/node-groups/:nodegroupName');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/clusters/:name/node-groups/:nodegroupName")

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

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

import requests

url = "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clusters/:name/node-groups/:nodegroupName")

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/clusters/:name/node-groups/:nodegroupName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/clusters/:name/node-groups/:nodegroupName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/clusters/:name/node-groups/:nodegroupName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName")! 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}}/clusters/:name/updates/:updateId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/clusters/:name/updates/:updateId")

require "http/client"

url = "{{baseUrl}}/clusters/:name/updates/:updateId"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/clusters/:name/updates/:updateId"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/clusters/:name/updates/:updateId'
};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/clusters/:name/updates/:updateId');

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}}/clusters/:name/updates/:updateId'
};

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

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

const url = '{{baseUrl}}/clusters/:name/updates/:updateId';
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}}/clusters/:name/updates/:updateId"]
                                                       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}}/clusters/:name/updates/:updateId" in

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

 "{{baseUrl}}/clusters/:name/updates/:updateId",
  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}}/clusters/:name/updates/:updateId');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("GET", "/baseUrl/clusters/:name/updates/:updateId")

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

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

import requests

url = "{{baseUrl}}/clusters/:name/updates/:updateId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/clusters/:name/updates/:updateId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clusters/:name/updates/:updateId")

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/clusters/:name/updates/:updateId') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/clusters/:name/updates/:updateId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/clusters/:name/updates/:updateId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clusters/:name/updates/:updateId")! 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}}/clusters/:name/identity-provider-configs/disassociate");

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  \"identityProviderConfig\": {\n    \"type\": \"\",\n    \"name\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate" {:content-type :json
                                                                                                  :form-params {:identityProviderConfig {:type ""
                                                                                                                                         :name ""}
                                                                                                                :clientRequestToken ""}})

require "http/client"

url = "{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"identityProviderConfig\": {\n    \"type\": \"\",\n    \"name\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate"),
    Content = new StringContent("{\n  \"identityProviderConfig\": {\n    \"type\": \"\",\n    \"name\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"identityProviderConfig\": {\n    \"type\": \"\",\n    \"name\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate"

	payload := strings.NewReader("{\n  \"identityProviderConfig\": {\n    \"type\": \"\",\n    \"name\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/clusters/:name/identity-provider-configs/disassociate HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 96

{
  "identityProviderConfig": {
    "type": "",
    "name": ""
  },
  "clientRequestToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"identityProviderConfig\": {\n    \"type\": \"\",\n    \"name\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"identityProviderConfig\": {\n    \"type\": \"\",\n    \"name\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"identityProviderConfig\": {\n    \"type\": \"\",\n    \"name\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate")
  .header("content-type", "application/json")
  .body("{\n  \"identityProviderConfig\": {\n    \"type\": \"\",\n    \"name\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  identityProviderConfig: {
    type: '',
    name: ''
  },
  clientRequestToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate',
  headers: {'content-type': 'application/json'},
  data: {identityProviderConfig: {type: '', name: ''}, clientRequestToken: ''}
};

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

const url = '{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"identityProviderConfig":{"type":"","name":""},"clientRequestToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "identityProviderConfig": {\n    "type": "",\n    "name": ""\n  },\n  "clientRequestToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"identityProviderConfig\": {\n    \"type\": \"\",\n    \"name\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate")
  .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/clusters/:name/identity-provider-configs/disassociate',
  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({identityProviderConfig: {type: '', name: ''}, clientRequestToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate',
  headers: {'content-type': 'application/json'},
  body: {identityProviderConfig: {type: '', name: ''}, clientRequestToken: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate');

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

req.type('json');
req.send({
  identityProviderConfig: {
    type: '',
    name: ''
  },
  clientRequestToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate',
  headers: {'content-type': 'application/json'},
  data: {identityProviderConfig: {type: '', name: ''}, clientRequestToken: ''}
};

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

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

const url = '{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"identityProviderConfig":{"type":"","name":""},"clientRequestToken":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"identityProviderConfig": @{ @"type": @"", @"name": @"" },
                              @"clientRequestToken": @"" };

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

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

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

 "{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate",
  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([
    'identityProviderConfig' => [
        'type' => '',
        'name' => ''
    ],
    'clientRequestToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate', [
  'body' => '{
  "identityProviderConfig": {
    "type": "",
    "name": ""
  },
  "clientRequestToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'identityProviderConfig' => [
    'type' => '',
    'name' => ''
  ],
  'clientRequestToken' => ''
]));

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

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

append(json_encode([
  'identityProviderConfig' => [
    'type' => '',
    'name' => ''
  ],
  'clientRequestToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate');
$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}}/clusters/:name/identity-provider-configs/disassociate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "identityProviderConfig": {
    "type": "",
    "name": ""
  },
  "clientRequestToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "identityProviderConfig": {
    "type": "",
    "name": ""
  },
  "clientRequestToken": ""
}'

import http.client

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

payload = "{\n  \"identityProviderConfig\": {\n    \"type\": \"\",\n    \"name\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/clusters/:name/identity-provider-configs/disassociate", payload, headers)

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

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

import requests

url = "{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate"

payload = {
    "identityProviderConfig": {
        "type": "",
        "name": ""
    },
    "clientRequestToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate"

payload <- "{\n  \"identityProviderConfig\": {\n    \"type\": \"\",\n    \"name\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate")

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  \"identityProviderConfig\": {\n    \"type\": \"\",\n    \"name\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/clusters/:name/identity-provider-configs/disassociate') do |req|
  req.body = "{\n  \"identityProviderConfig\": {\n    \"type\": \"\",\n    \"name\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate";

    let payload = json!({
        "identityProviderConfig": json!({
            "type": "",
            "name": ""
        }),
        "clientRequestToken": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "identityProviderConfig": {
    "type": "",
    "name": ""
  },
  "clientRequestToken": ""
}' |  \
  http POST {{baseUrl}}/clusters/:name/identity-provider-configs/disassociate \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "identityProviderConfig": {\n    "type": "",\n    "name": ""\n  },\n  "clientRequestToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/clusters/:name/identity-provider-configs/disassociate

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clusters/:name/identity-provider-configs/disassociate")! 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}}/clusters/:name/addons");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/clusters/:name/addons")

require "http/client"

url = "{{baseUrl}}/clusters/:name/addons"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/clusters/:name/addons"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/clusters/:name/addons');

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}}/clusters/:name/addons'};

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/clusters/:name/addons"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/clusters/:name/addons"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clusters/:name/addons")

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/clusters/:name/addons') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/clusters/:name/addons

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

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/clusters"

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/clusters",
  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}}/clusters');

echo $response->getBody();

setUrl('{{baseUrl}}/clusters');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/clusters');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/clusters' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/clusters' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/clusters")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/clusters"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/clusters"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clusters")

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/clusters') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/clusters";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/clusters

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/clusters

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clusters")! 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}}/clusters/:name/fargate-profiles");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/clusters/:name/fargate-profiles")

require "http/client"

url = "{{baseUrl}}/clusters/:name/fargate-profiles"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/clusters/:name/fargate-profiles"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/clusters/:name/fargate-profiles");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/clusters/:name/fargate-profiles"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/clusters/:name/fargate-profiles HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/clusters/:name/fargate-profiles")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clusters/:name/fargate-profiles"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/clusters/:name/fargate-profiles")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/clusters/:name/fargate-profiles")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/clusters/:name/fargate-profiles');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/clusters/:name/fargate-profiles'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/clusters/:name/fargate-profiles';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/clusters/:name/fargate-profiles',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/clusters/:name/fargate-profiles")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/clusters/:name/fargate-profiles',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/clusters/:name/fargate-profiles'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/clusters/:name/fargate-profiles');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/clusters/:name/fargate-profiles'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/clusters/:name/fargate-profiles';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/clusters/:name/fargate-profiles"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/clusters/:name/fargate-profiles" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/clusters/:name/fargate-profiles",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/clusters/:name/fargate-profiles');

echo $response->getBody();

setUrl('{{baseUrl}}/clusters/:name/fargate-profiles');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/clusters/:name/fargate-profiles');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/clusters/:name/fargate-profiles' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/clusters/:name/fargate-profiles' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/clusters/:name/fargate-profiles")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/clusters/:name/fargate-profiles"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/clusters/:name/fargate-profiles"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clusters/:name/fargate-profiles")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/clusters/:name/fargate-profiles') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/clusters/:name/fargate-profiles";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/clusters/:name/fargate-profiles

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/clusters/:name/fargate-profiles

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clusters/:name/fargate-profiles")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/clusters/:name/identity-provider-configs");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/clusters/:name/identity-provider-configs")

require "http/client"

url = "{{baseUrl}}/clusters/:name/identity-provider-configs"

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}}/clusters/:name/identity-provider-configs"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/clusters/:name/identity-provider-configs");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/clusters/:name/identity-provider-configs"

	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/clusters/:name/identity-provider-configs HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/clusters/:name/identity-provider-configs")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clusters/:name/identity-provider-configs"))
    .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}}/clusters/:name/identity-provider-configs")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/clusters/:name/identity-provider-configs")
  .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}}/clusters/:name/identity-provider-configs');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/clusters/:name/identity-provider-configs'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/clusters/:name/identity-provider-configs';
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}}/clusters/:name/identity-provider-configs',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/clusters/:name/identity-provider-configs")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/clusters/:name/identity-provider-configs',
  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}}/clusters/:name/identity-provider-configs'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/clusters/:name/identity-provider-configs');

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}}/clusters/:name/identity-provider-configs'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/clusters/:name/identity-provider-configs';
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}}/clusters/:name/identity-provider-configs"]
                                                       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}}/clusters/:name/identity-provider-configs" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/clusters/:name/identity-provider-configs",
  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}}/clusters/:name/identity-provider-configs');

echo $response->getBody();

setUrl('{{baseUrl}}/clusters/:name/identity-provider-configs');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/clusters/:name/identity-provider-configs');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/clusters/:name/identity-provider-configs' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/clusters/:name/identity-provider-configs' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/clusters/:name/identity-provider-configs")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/clusters/:name/identity-provider-configs"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/clusters/:name/identity-provider-configs"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clusters/:name/identity-provider-configs")

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/clusters/:name/identity-provider-configs') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/clusters/:name/identity-provider-configs";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/clusters/:name/identity-provider-configs

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/clusters/:name/identity-provider-configs

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clusters/:name/identity-provider-configs")! 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}}/clusters/:name/node-groups");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/clusters/:name/node-groups")

require "http/client"

url = "{{baseUrl}}/clusters/:name/node-groups"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/clusters/:name/node-groups"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/clusters/:name/node-groups");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/clusters/:name/node-groups"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/clusters/:name/node-groups HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/clusters/:name/node-groups")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clusters/:name/node-groups"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/clusters/:name/node-groups")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/clusters/:name/node-groups")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/clusters/:name/node-groups');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/clusters/:name/node-groups'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/clusters/:name/node-groups';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/clusters/:name/node-groups',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/clusters/:name/node-groups")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/clusters/:name/node-groups',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/clusters/:name/node-groups'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/clusters/:name/node-groups');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/clusters/:name/node-groups'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/clusters/:name/node-groups';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/clusters/:name/node-groups"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/clusters/:name/node-groups" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/clusters/:name/node-groups",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/clusters/:name/node-groups');

echo $response->getBody();

setUrl('{{baseUrl}}/clusters/:name/node-groups');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/clusters/:name/node-groups');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/clusters/:name/node-groups' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/clusters/:name/node-groups' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/clusters/:name/node-groups")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/clusters/:name/node-groups"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/clusters/:name/node-groups"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clusters/:name/node-groups")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/clusters/:name/node-groups') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/clusters/:name/node-groups";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/clusters/:name/node-groups

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/clusters/:name/node-groups

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clusters/:name/node-groups")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tags/:resourceArn");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tags/:resourceArn")

require "http/client"

url = "{{baseUrl}}/tags/:resourceArn"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/tags/:resourceArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tags/:resourceArn");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tags/:resourceArn"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/tags/:resourceArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tags/:resourceArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tags/:resourceArn"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tags/:resourceArn")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/tags/:resourceArn');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/tags/:resourceArn'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tags/:resourceArn';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/tags/:resourceArn',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tags/:resourceArn',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/tags/:resourceArn'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tags/:resourceArn');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/tags/:resourceArn'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tags/:resourceArn';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tags/:resourceArn"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/tags/:resourceArn" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tags/:resourceArn",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/tags/:resourceArn');

echo $response->getBody();

setUrl('{{baseUrl}}/tags/:resourceArn');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tags/:resourceArn');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/tags/:resourceArn' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/tags/:resourceArn' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/tags/:resourceArn")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tags/:resourceArn"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags/:resourceArn"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tags/:resourceArn")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/tags/:resourceArn') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tags/: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}}/tags/:resourceArn

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/tags/:resourceArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tags/: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}}/clusters/:name/updates");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/clusters/:name/updates")

require "http/client"

url = "{{baseUrl}}/clusters/:name/updates"

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}}/clusters/:name/updates"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/clusters/:name/updates");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/clusters/:name/updates"

	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/clusters/:name/updates HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/clusters/:name/updates")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clusters/:name/updates"))
    .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}}/clusters/:name/updates")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/clusters/:name/updates")
  .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}}/clusters/:name/updates');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/clusters/:name/updates'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/clusters/:name/updates';
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}}/clusters/:name/updates',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/clusters/:name/updates")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/clusters/:name/updates',
  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}}/clusters/:name/updates'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/clusters/:name/updates');

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}}/clusters/:name/updates'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/clusters/:name/updates';
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}}/clusters/:name/updates"]
                                                       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}}/clusters/:name/updates" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/clusters/:name/updates",
  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}}/clusters/:name/updates');

echo $response->getBody();

setUrl('{{baseUrl}}/clusters/:name/updates');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/clusters/:name/updates');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/clusters/:name/updates' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/clusters/:name/updates' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/clusters/:name/updates")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/clusters/:name/updates"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/clusters/:name/updates"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clusters/:name/updates")

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/clusters/:name/updates') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/clusters/:name/updates";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/clusters/:name/updates

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/clusters/:name/updates

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clusters/:name/updates")! 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}}/cluster-registrations");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\",\n  \"connectorConfig\": {\n    \"roleArn\": \"\",\n    \"provider\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/cluster-registrations" {:content-type :json
                                                                  :form-params {:name ""
                                                                                :connectorConfig {:roleArn ""
                                                                                                  :provider ""}
                                                                                :clientRequestToken ""
                                                                                :tags {}}})

require "http/client"

url = "{{baseUrl}}/cluster-registrations"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"connectorConfig\": {\n    \"roleArn\": \"\",\n    \"provider\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/cluster-registrations"),
    Content = new StringContent("{\n  \"name\": \"\",\n  \"connectorConfig\": {\n    \"roleArn\": \"\",\n    \"provider\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/cluster-registrations");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"connectorConfig\": {\n    \"roleArn\": \"\",\n    \"provider\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/cluster-registrations"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"connectorConfig\": {\n    \"roleArn\": \"\",\n    \"provider\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/cluster-registrations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 124

{
  "name": "",
  "connectorConfig": {
    "roleArn": "",
    "provider": ""
  },
  "clientRequestToken": "",
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/cluster-registrations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"connectorConfig\": {\n    \"roleArn\": \"\",\n    \"provider\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/cluster-registrations"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"connectorConfig\": {\n    \"roleArn\": \"\",\n    \"provider\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"connectorConfig\": {\n    \"roleArn\": \"\",\n    \"provider\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/cluster-registrations")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/cluster-registrations")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"connectorConfig\": {\n    \"roleArn\": \"\",\n    \"provider\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  connectorConfig: {
    roleArn: '',
    provider: ''
  },
  clientRequestToken: '',
  tags: {}
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/cluster-registrations');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/cluster-registrations',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    connectorConfig: {roleArn: '', provider: ''},
    clientRequestToken: '',
    tags: {}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/cluster-registrations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","connectorConfig":{"roleArn":"","provider":""},"clientRequestToken":"","tags":{}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/cluster-registrations',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "connectorConfig": {\n    "roleArn": "",\n    "provider": ""\n  },\n  "clientRequestToken": "",\n  "tags": {}\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"connectorConfig\": {\n    \"roleArn\": \"\",\n    \"provider\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/cluster-registrations")
  .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/cluster-registrations',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  name: '',
  connectorConfig: {roleArn: '', provider: ''},
  clientRequestToken: '',
  tags: {}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/cluster-registrations',
  headers: {'content-type': 'application/json'},
  body: {
    name: '',
    connectorConfig: {roleArn: '', provider: ''},
    clientRequestToken: '',
    tags: {}
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/cluster-registrations');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: '',
  connectorConfig: {
    roleArn: '',
    provider: ''
  },
  clientRequestToken: '',
  tags: {}
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/cluster-registrations',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    connectorConfig: {roleArn: '', provider: ''},
    clientRequestToken: '',
    tags: {}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/cluster-registrations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","connectorConfig":{"roleArn":"","provider":""},"clientRequestToken":"","tags":{}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"name": @"",
                              @"connectorConfig": @{ @"roleArn": @"", @"provider": @"" },
                              @"clientRequestToken": @"",
                              @"tags": @{  } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/cluster-registrations"]
                                                       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}}/cluster-registrations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"connectorConfig\": {\n    \"roleArn\": \"\",\n    \"provider\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/cluster-registrations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => '',
    'connectorConfig' => [
        'roleArn' => '',
        'provider' => ''
    ],
    'clientRequestToken' => '',
    'tags' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/cluster-registrations', [
  'body' => '{
  "name": "",
  "connectorConfig": {
    "roleArn": "",
    "provider": ""
  },
  "clientRequestToken": "",
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/cluster-registrations');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'connectorConfig' => [
    'roleArn' => '',
    'provider' => ''
  ],
  'clientRequestToken' => '',
  'tags' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'name' => '',
  'connectorConfig' => [
    'roleArn' => '',
    'provider' => ''
  ],
  'clientRequestToken' => '',
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/cluster-registrations');
$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}}/cluster-registrations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "connectorConfig": {
    "roleArn": "",
    "provider": ""
  },
  "clientRequestToken": "",
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/cluster-registrations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "connectorConfig": {
    "roleArn": "",
    "provider": ""
  },
  "clientRequestToken": "",
  "tags": {}
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"name\": \"\",\n  \"connectorConfig\": {\n    \"roleArn\": \"\",\n    \"provider\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/cluster-registrations", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/cluster-registrations"

payload = {
    "name": "",
    "connectorConfig": {
        "roleArn": "",
        "provider": ""
    },
    "clientRequestToken": "",
    "tags": {}
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/cluster-registrations"

payload <- "{\n  \"name\": \"\",\n  \"connectorConfig\": {\n    \"roleArn\": \"\",\n    \"provider\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/cluster-registrations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"connectorConfig\": {\n    \"roleArn\": \"\",\n    \"provider\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/cluster-registrations') do |req|
  req.body = "{\n  \"name\": \"\",\n  \"connectorConfig\": {\n    \"roleArn\": \"\",\n    \"provider\": \"\"\n  },\n  \"clientRequestToken\": \"\",\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/cluster-registrations";

    let payload = json!({
        "name": "",
        "connectorConfig": json!({
            "roleArn": "",
            "provider": ""
        }),
        "clientRequestToken": "",
        "tags": json!({})
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "name": "",
  "connectorConfig": {
    "roleArn": "",
    "provider": ""
  },
  "clientRequestToken": "",
  "tags": {}
}' |  \
  http POST {{baseUrl}}/cluster-registrations \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "connectorConfig": {\n    "roleArn": "",\n    "provider": ""\n  },\n  "clientRequestToken": "",\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/cluster-registrations

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "name": "",
  "connectorConfig": [
    "roleArn": "",
    "provider": ""
  ],
  "clientRequestToken": "",
  "tags": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/cluster-registrations")! 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}}/tags/:resourceArn");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"tags\": {}\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/tags/:resourceArn" {:content-type :json
                                                              :form-params {:tags {}}})

require "http/client"

url = "{{baseUrl}}/tags/:resourceArn"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"tags\": {}\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/tags/:resourceArn"),
    Content = new StringContent("{\n  \"tags\": {}\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tags/:resourceArn");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"tags\": {}\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tags/:resourceArn"

	payload := strings.NewReader("{\n  \"tags\": {}\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/tags/:resourceArn HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "tags": {}
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/tags/:resourceArn")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"tags\": {}\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tags/:resourceArn"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"tags\": {}\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"tags\": {}\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/tags/:resourceArn")
  .header("content-type", "application/json")
  .body("{\n  \"tags\": {}\n}")
  .asString();

const data = JSON.stringify({
  tags: {}
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/tags/:resourceArn');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tags/:resourceArn',
  headers: {'content-type': 'application/json'},
  data: {tags: {}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tags/:resourceArn';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"tags":{}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/tags/:resourceArn',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "tags": {}\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"tags\": {}\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tags/:resourceArn',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({tags: {}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tags/:resourceArn',
  headers: {'content-type': 'application/json'},
  body: {tags: {}},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/tags/:resourceArn');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  tags: {}
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tags/:resourceArn',
  headers: {'content-type': 'application/json'},
  data: {tags: {}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tags/:resourceArn';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"tags":{}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"tags": @{  } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tags/:resourceArn"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/tags/:resourceArn" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"tags\": {}\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tags/:resourceArn",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'tags' => [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/tags/:resourceArn', [
  'body' => '{
  "tags": {}
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tags/:resourceArn');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'tags' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'tags' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/tags/:resourceArn');
$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}}/tags/:resourceArn' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "tags": {}
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tags/:resourceArn' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "tags": {}
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"tags\": {}\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/tags/:resourceArn", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tags/:resourceArn"

payload = { "tags": {} }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags/:resourceArn"

payload <- "{\n  \"tags\": {}\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tags/:resourceArn")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"tags\": {}\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/tags/:resourceArn') do |req|
  req.body = "{\n  \"tags\": {}\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tags/:resourceArn";

    let payload = json!({"tags": json!({})});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "tags": {}
}' |  \
  http POST {{baseUrl}}/tags/:resourceArn \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "tags": {}\n}' \
  --output-document \
  - {{baseUrl}}/tags/:resourceArn

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["tags": []] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tags/:resourceArn")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/tags/:resourceArn#tagKeys" {:query-params {:tagKeys ""}})

require "http/client"

url = "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/tags/:resourceArn?tagKeys= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/tags/:resourceArn#tagKeys',
  params: {tagKeys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tags/:resourceArn?tagKeys=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/tags/:resourceArn#tagKeys',
  qs: {tagKeys: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/tags/:resourceArn#tagKeys');

req.query({
  tagKeys: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/tags/:resourceArn#tagKeys',
  params: {tagKeys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys');

echo $response->getBody();

setUrl('{{baseUrl}}/tags/:resourceArn#tagKeys');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'tagKeys' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tags/:resourceArn#tagKeys');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'tagKeys' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/tags/:resourceArn?tagKeys=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tags/:resourceArn#tagKeys"

querystring = {"tagKeys":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags/:resourceArn#tagKeys"

queryString <- list(tagKeys = "")

response <- VERB("DELETE", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/tags/:resourceArn') do |req|
  req.params['tagKeys'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tags/:resourceArn#tagKeys";

    let querystring = [
        ("tagKeys", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys'

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/clusters/:name/addons/:addonName/update");

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  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"configurationValues\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/clusters/:name/addons/:addonName/update" {:content-type :json
                                                                                    :form-params {:addonVersion ""
                                                                                                  :serviceAccountRoleArn ""
                                                                                                  :resolveConflicts ""
                                                                                                  :clientRequestToken ""
                                                                                                  :configurationValues ""}})

require "http/client"

url = "{{baseUrl}}/clusters/:name/addons/:addonName/update"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"configurationValues\": \"\"\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}}/clusters/:name/addons/:addonName/update"),
    Content = new StringContent("{\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"configurationValues\": \"\"\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}}/clusters/:name/addons/:addonName/update");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"configurationValues\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/clusters/:name/addons/:addonName/update"

	payload := strings.NewReader("{\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"configurationValues\": \"\"\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/clusters/:name/addons/:addonName/update HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 138

{
  "addonVersion": "",
  "serviceAccountRoleArn": "",
  "resolveConflicts": "",
  "clientRequestToken": "",
  "configurationValues": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/clusters/:name/addons/:addonName/update")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"configurationValues\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clusters/:name/addons/:addonName/update"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"configurationValues\": \"\"\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  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"configurationValues\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/clusters/:name/addons/:addonName/update")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/clusters/:name/addons/:addonName/update")
  .header("content-type", "application/json")
  .body("{\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"configurationValues\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  addonVersion: '',
  serviceAccountRoleArn: '',
  resolveConflicts: '',
  clientRequestToken: '',
  configurationValues: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/clusters/:name/addons/:addonName/update');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/addons/:addonName/update',
  headers: {'content-type': 'application/json'},
  data: {
    addonVersion: '',
    serviceAccountRoleArn: '',
    resolveConflicts: '',
    clientRequestToken: '',
    configurationValues: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/clusters/:name/addons/:addonName/update';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"addonVersion":"","serviceAccountRoleArn":"","resolveConflicts":"","clientRequestToken":"","configurationValues":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/clusters/:name/addons/:addonName/update',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "addonVersion": "",\n  "serviceAccountRoleArn": "",\n  "resolveConflicts": "",\n  "clientRequestToken": "",\n  "configurationValues": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"configurationValues\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/clusters/:name/addons/:addonName/update")
  .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/clusters/:name/addons/:addonName/update',
  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({
  addonVersion: '',
  serviceAccountRoleArn: '',
  resolveConflicts: '',
  clientRequestToken: '',
  configurationValues: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/addons/:addonName/update',
  headers: {'content-type': 'application/json'},
  body: {
    addonVersion: '',
    serviceAccountRoleArn: '',
    resolveConflicts: '',
    clientRequestToken: '',
    configurationValues: ''
  },
  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}}/clusters/:name/addons/:addonName/update');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  addonVersion: '',
  serviceAccountRoleArn: '',
  resolveConflicts: '',
  clientRequestToken: '',
  configurationValues: ''
});

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}}/clusters/:name/addons/:addonName/update',
  headers: {'content-type': 'application/json'},
  data: {
    addonVersion: '',
    serviceAccountRoleArn: '',
    resolveConflicts: '',
    clientRequestToken: '',
    configurationValues: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/clusters/:name/addons/:addonName/update';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"addonVersion":"","serviceAccountRoleArn":"","resolveConflicts":"","clientRequestToken":"","configurationValues":""}'
};

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 = @{ @"addonVersion": @"",
                              @"serviceAccountRoleArn": @"",
                              @"resolveConflicts": @"",
                              @"clientRequestToken": @"",
                              @"configurationValues": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/clusters/:name/addons/:addonName/update"]
                                                       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}}/clusters/:name/addons/:addonName/update" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"configurationValues\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/clusters/:name/addons/:addonName/update",
  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([
    'addonVersion' => '',
    'serviceAccountRoleArn' => '',
    'resolveConflicts' => '',
    'clientRequestToken' => '',
    'configurationValues' => ''
  ]),
  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}}/clusters/:name/addons/:addonName/update', [
  'body' => '{
  "addonVersion": "",
  "serviceAccountRoleArn": "",
  "resolveConflicts": "",
  "clientRequestToken": "",
  "configurationValues": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/clusters/:name/addons/:addonName/update');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'addonVersion' => '',
  'serviceAccountRoleArn' => '',
  'resolveConflicts' => '',
  'clientRequestToken' => '',
  'configurationValues' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'addonVersion' => '',
  'serviceAccountRoleArn' => '',
  'resolveConflicts' => '',
  'clientRequestToken' => '',
  'configurationValues' => ''
]));
$request->setRequestUrl('{{baseUrl}}/clusters/:name/addons/:addonName/update');
$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}}/clusters/:name/addons/:addonName/update' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "addonVersion": "",
  "serviceAccountRoleArn": "",
  "resolveConflicts": "",
  "clientRequestToken": "",
  "configurationValues": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/clusters/:name/addons/:addonName/update' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "addonVersion": "",
  "serviceAccountRoleArn": "",
  "resolveConflicts": "",
  "clientRequestToken": "",
  "configurationValues": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"configurationValues\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/clusters/:name/addons/:addonName/update", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/clusters/:name/addons/:addonName/update"

payload = {
    "addonVersion": "",
    "serviceAccountRoleArn": "",
    "resolveConflicts": "",
    "clientRequestToken": "",
    "configurationValues": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/clusters/:name/addons/:addonName/update"

payload <- "{\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"configurationValues\": \"\"\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}}/clusters/:name/addons/:addonName/update")

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  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"configurationValues\": \"\"\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/clusters/:name/addons/:addonName/update') do |req|
  req.body = "{\n  \"addonVersion\": \"\",\n  \"serviceAccountRoleArn\": \"\",\n  \"resolveConflicts\": \"\",\n  \"clientRequestToken\": \"\",\n  \"configurationValues\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/clusters/:name/addons/:addonName/update";

    let payload = json!({
        "addonVersion": "",
        "serviceAccountRoleArn": "",
        "resolveConflicts": "",
        "clientRequestToken": "",
        "configurationValues": ""
    });

    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 '{
  "addonVersion": "",
  "serviceAccountRoleArn": "",
  "resolveConflicts": "",
  "clientRequestToken": "",
  "configurationValues": ""
}' |  \
  http POST {{baseUrl}}/clusters/:name/addons/:addonName/update \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "addonVersion": "",\n  "serviceAccountRoleArn": "",\n  "resolveConflicts": "",\n  "clientRequestToken": "",\n  "configurationValues": ""\n}' \
  --output-document \
  - {{baseUrl}}/clusters/:name/addons/:addonName/update

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "addonVersion": "",
  "serviceAccountRoleArn": "",
  "resolveConflicts": "",
  "clientRequestToken": "",
  "configurationValues": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clusters/:name/addons/:addonName/update")! 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}}/clusters/:name/update-config");

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  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/clusters/:name/update-config" {:content-type :json
                                                                         :form-params {:resourcesVpcConfig {:subnetIds ""
                                                                                                            :securityGroupIds ""
                                                                                                            :endpointPublicAccess ""
                                                                                                            :endpointPrivateAccess ""
                                                                                                            :publicAccessCidrs ""}
                                                                                       :logging {:clusterLogging ""}
                                                                                       :clientRequestToken ""}})

require "http/client"

url = "{{baseUrl}}/clusters/:name/update-config"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/clusters/:name/update-config"),
    Content = new StringContent("{\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/clusters/:name/update-config");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/clusters/:name/update-config"

	payload := strings.NewReader("{\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/clusters/:name/update-config HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 248

{
  "resourcesVpcConfig": {
    "subnetIds": "",
    "securityGroupIds": "",
    "endpointPublicAccess": "",
    "endpointPrivateAccess": "",
    "publicAccessCidrs": ""
  },
  "logging": {
    "clusterLogging": ""
  },
  "clientRequestToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/clusters/:name/update-config")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clusters/:name/update-config"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/clusters/:name/update-config")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/clusters/:name/update-config")
  .header("content-type", "application/json")
  .body("{\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  resourcesVpcConfig: {
    subnetIds: '',
    securityGroupIds: '',
    endpointPublicAccess: '',
    endpointPrivateAccess: '',
    publicAccessCidrs: ''
  },
  logging: {
    clusterLogging: ''
  },
  clientRequestToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/clusters/:name/update-config');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/update-config',
  headers: {'content-type': 'application/json'},
  data: {
    resourcesVpcConfig: {
      subnetIds: '',
      securityGroupIds: '',
      endpointPublicAccess: '',
      endpointPrivateAccess: '',
      publicAccessCidrs: ''
    },
    logging: {clusterLogging: ''},
    clientRequestToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/clusters/:name/update-config';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourcesVpcConfig":{"subnetIds":"","securityGroupIds":"","endpointPublicAccess":"","endpointPrivateAccess":"","publicAccessCidrs":""},"logging":{"clusterLogging":""},"clientRequestToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/clusters/:name/update-config',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resourcesVpcConfig": {\n    "subnetIds": "",\n    "securityGroupIds": "",\n    "endpointPublicAccess": "",\n    "endpointPrivateAccess": "",\n    "publicAccessCidrs": ""\n  },\n  "logging": {\n    "clusterLogging": ""\n  },\n  "clientRequestToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/clusters/:name/update-config")
  .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/clusters/:name/update-config',
  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({
  resourcesVpcConfig: {
    subnetIds: '',
    securityGroupIds: '',
    endpointPublicAccess: '',
    endpointPrivateAccess: '',
    publicAccessCidrs: ''
  },
  logging: {clusterLogging: ''},
  clientRequestToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/update-config',
  headers: {'content-type': 'application/json'},
  body: {
    resourcesVpcConfig: {
      subnetIds: '',
      securityGroupIds: '',
      endpointPublicAccess: '',
      endpointPrivateAccess: '',
      publicAccessCidrs: ''
    },
    logging: {clusterLogging: ''},
    clientRequestToken: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/clusters/:name/update-config');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  resourcesVpcConfig: {
    subnetIds: '',
    securityGroupIds: '',
    endpointPublicAccess: '',
    endpointPrivateAccess: '',
    publicAccessCidrs: ''
  },
  logging: {
    clusterLogging: ''
  },
  clientRequestToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/update-config',
  headers: {'content-type': 'application/json'},
  data: {
    resourcesVpcConfig: {
      subnetIds: '',
      securityGroupIds: '',
      endpointPublicAccess: '',
      endpointPrivateAccess: '',
      publicAccessCidrs: ''
    },
    logging: {clusterLogging: ''},
    clientRequestToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/clusters/:name/update-config';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"resourcesVpcConfig":{"subnetIds":"","securityGroupIds":"","endpointPublicAccess":"","endpointPrivateAccess":"","publicAccessCidrs":""},"logging":{"clusterLogging":""},"clientRequestToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"resourcesVpcConfig": @{ @"subnetIds": @"", @"securityGroupIds": @"", @"endpointPublicAccess": @"", @"endpointPrivateAccess": @"", @"publicAccessCidrs": @"" },
                              @"logging": @{ @"clusterLogging": @"" },
                              @"clientRequestToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/clusters/:name/update-config"]
                                                       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}}/clusters/:name/update-config" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/clusters/:name/update-config",
  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([
    'resourcesVpcConfig' => [
        'subnetIds' => '',
        'securityGroupIds' => '',
        'endpointPublicAccess' => '',
        'endpointPrivateAccess' => '',
        'publicAccessCidrs' => ''
    ],
    'logging' => [
        'clusterLogging' => ''
    ],
    'clientRequestToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/clusters/:name/update-config', [
  'body' => '{
  "resourcesVpcConfig": {
    "subnetIds": "",
    "securityGroupIds": "",
    "endpointPublicAccess": "",
    "endpointPrivateAccess": "",
    "publicAccessCidrs": ""
  },
  "logging": {
    "clusterLogging": ""
  },
  "clientRequestToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/clusters/:name/update-config');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resourcesVpcConfig' => [
    'subnetIds' => '',
    'securityGroupIds' => '',
    'endpointPublicAccess' => '',
    'endpointPrivateAccess' => '',
    'publicAccessCidrs' => ''
  ],
  'logging' => [
    'clusterLogging' => ''
  ],
  'clientRequestToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'resourcesVpcConfig' => [
    'subnetIds' => '',
    'securityGroupIds' => '',
    'endpointPublicAccess' => '',
    'endpointPrivateAccess' => '',
    'publicAccessCidrs' => ''
  ],
  'logging' => [
    'clusterLogging' => ''
  ],
  'clientRequestToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/clusters/:name/update-config');
$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}}/clusters/:name/update-config' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourcesVpcConfig": {
    "subnetIds": "",
    "securityGroupIds": "",
    "endpointPublicAccess": "",
    "endpointPrivateAccess": "",
    "publicAccessCidrs": ""
  },
  "logging": {
    "clusterLogging": ""
  },
  "clientRequestToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/clusters/:name/update-config' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourcesVpcConfig": {
    "subnetIds": "",
    "securityGroupIds": "",
    "endpointPublicAccess": "",
    "endpointPrivateAccess": "",
    "publicAccessCidrs": ""
  },
  "logging": {
    "clusterLogging": ""
  },
  "clientRequestToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/clusters/:name/update-config", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/clusters/:name/update-config"

payload = {
    "resourcesVpcConfig": {
        "subnetIds": "",
        "securityGroupIds": "",
        "endpointPublicAccess": "",
        "endpointPrivateAccess": "",
        "publicAccessCidrs": ""
    },
    "logging": { "clusterLogging": "" },
    "clientRequestToken": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/clusters/:name/update-config"

payload <- "{\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clusters/:name/update-config")

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  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/clusters/:name/update-config') do |req|
  req.body = "{\n  \"resourcesVpcConfig\": {\n    \"subnetIds\": \"\",\n    \"securityGroupIds\": \"\",\n    \"endpointPublicAccess\": \"\",\n    \"endpointPrivateAccess\": \"\",\n    \"publicAccessCidrs\": \"\"\n  },\n  \"logging\": {\n    \"clusterLogging\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/clusters/:name/update-config";

    let payload = json!({
        "resourcesVpcConfig": json!({
            "subnetIds": "",
            "securityGroupIds": "",
            "endpointPublicAccess": "",
            "endpointPrivateAccess": "",
            "publicAccessCidrs": ""
        }),
        "logging": json!({"clusterLogging": ""}),
        "clientRequestToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "resourcesVpcConfig": {
    "subnetIds": "",
    "securityGroupIds": "",
    "endpointPublicAccess": "",
    "endpointPrivateAccess": "",
    "publicAccessCidrs": ""
  },
  "logging": {
    "clusterLogging": ""
  },
  "clientRequestToken": ""
}' |  \
  http POST {{baseUrl}}/clusters/:name/update-config \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourcesVpcConfig": {\n    "subnetIds": "",\n    "securityGroupIds": "",\n    "endpointPublicAccess": "",\n    "endpointPrivateAccess": "",\n    "publicAccessCidrs": ""\n  },\n  "logging": {\n    "clusterLogging": ""\n  },\n  "clientRequestToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/clusters/:name/update-config

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "resourcesVpcConfig": [
    "subnetIds": "",
    "securityGroupIds": "",
    "endpointPublicAccess": "",
    "endpointPrivateAccess": "",
    "publicAccessCidrs": ""
  ],
  "logging": ["clusterLogging": ""],
  "clientRequestToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clusters/:name/update-config")! 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}}/clusters/:name/updates");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"version\": \"\",\n  \"clientRequestToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/clusters/:name/updates" {:content-type :json
                                                                   :form-params {:version ""
                                                                                 :clientRequestToken ""}})

require "http/client"

url = "{{baseUrl}}/clusters/:name/updates"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"version\": \"\",\n  \"clientRequestToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/clusters/:name/updates"),
    Content = new StringContent("{\n  \"version\": \"\",\n  \"clientRequestToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/clusters/:name/updates");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"version\": \"\",\n  \"clientRequestToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/clusters/:name/updates"

	payload := strings.NewReader("{\n  \"version\": \"\",\n  \"clientRequestToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/clusters/:name/updates HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 47

{
  "version": "",
  "clientRequestToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/clusters/:name/updates")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"version\": \"\",\n  \"clientRequestToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clusters/:name/updates"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"version\": \"\",\n  \"clientRequestToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"version\": \"\",\n  \"clientRequestToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/clusters/:name/updates")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/clusters/:name/updates")
  .header("content-type", "application/json")
  .body("{\n  \"version\": \"\",\n  \"clientRequestToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  version: '',
  clientRequestToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/clusters/:name/updates');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/updates',
  headers: {'content-type': 'application/json'},
  data: {version: '', clientRequestToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/clusters/:name/updates';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"version":"","clientRequestToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/clusters/:name/updates',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "version": "",\n  "clientRequestToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"version\": \"\",\n  \"clientRequestToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/clusters/:name/updates")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/clusters/:name/updates',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({version: '', clientRequestToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/updates',
  headers: {'content-type': 'application/json'},
  body: {version: '', clientRequestToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/clusters/:name/updates');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  version: '',
  clientRequestToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/updates',
  headers: {'content-type': 'application/json'},
  data: {version: '', clientRequestToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/clusters/:name/updates';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"version":"","clientRequestToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"version": @"",
                              @"clientRequestToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/clusters/:name/updates"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/clusters/:name/updates" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"version\": \"\",\n  \"clientRequestToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/clusters/:name/updates",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'version' => '',
    'clientRequestToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/clusters/:name/updates', [
  'body' => '{
  "version": "",
  "clientRequestToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/clusters/:name/updates');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'version' => '',
  'clientRequestToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'version' => '',
  'clientRequestToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/clusters/:name/updates');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/clusters/:name/updates' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "version": "",
  "clientRequestToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/clusters/:name/updates' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "version": "",
  "clientRequestToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"version\": \"\",\n  \"clientRequestToken\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/clusters/:name/updates", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/clusters/:name/updates"

payload = {
    "version": "",
    "clientRequestToken": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/clusters/:name/updates"

payload <- "{\n  \"version\": \"\",\n  \"clientRequestToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clusters/:name/updates")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"version\": \"\",\n  \"clientRequestToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/clusters/:name/updates') do |req|
  req.body = "{\n  \"version\": \"\",\n  \"clientRequestToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/clusters/:name/updates";

    let payload = json!({
        "version": "",
        "clientRequestToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "version": "",
  "clientRequestToken": ""
}' |  \
  http POST {{baseUrl}}/clusters/:name/updates \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "version": "",\n  "clientRequestToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/clusters/:name/updates

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "version": "",
  "clientRequestToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clusters/:name/updates")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config");

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  \"labels\": {\n    \"addOrUpdateLabels\": \"\",\n    \"removeLabels\": \"\"\n  },\n  \"taints\": {\n    \"addOrUpdateTaints\": \"\",\n    \"removeTaints\": \"\"\n  },\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config" {:content-type :json
                                                                                                    :form-params {:labels {:addOrUpdateLabels ""
                                                                                                                           :removeLabels ""}
                                                                                                                  :taints {:addOrUpdateTaints ""
                                                                                                                           :removeTaints ""}
                                                                                                                  :scalingConfig {:minSize ""
                                                                                                                                  :maxSize ""
                                                                                                                                  :desiredSize ""}
                                                                                                                  :updateConfig {:maxUnavailable ""
                                                                                                                                 :maxUnavailablePercentage ""}
                                                                                                                  :clientRequestToken ""}})

require "http/client"

url = "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"labels\": {\n    \"addOrUpdateLabels\": \"\",\n    \"removeLabels\": \"\"\n  },\n  \"taints\": {\n    \"addOrUpdateTaints\": \"\",\n    \"removeTaints\": \"\"\n  },\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config"),
    Content = new StringContent("{\n  \"labels\": {\n    \"addOrUpdateLabels\": \"\",\n    \"removeLabels\": \"\"\n  },\n  \"taints\": {\n    \"addOrUpdateTaints\": \"\",\n    \"removeTaints\": \"\"\n  },\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"labels\": {\n    \"addOrUpdateLabels\": \"\",\n    \"removeLabels\": \"\"\n  },\n  \"taints\": {\n    \"addOrUpdateTaints\": \"\",\n    \"removeTaints\": \"\"\n  },\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config"

	payload := strings.NewReader("{\n  \"labels\": {\n    \"addOrUpdateLabels\": \"\",\n    \"removeLabels\": \"\"\n  },\n  \"taints\": {\n    \"addOrUpdateTaints\": \"\",\n    \"removeTaints\": \"\"\n  },\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/clusters/:name/node-groups/:nodegroupName/update-config HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 344

{
  "labels": {
    "addOrUpdateLabels": "",
    "removeLabels": ""
  },
  "taints": {
    "addOrUpdateTaints": "",
    "removeTaints": ""
  },
  "scalingConfig": {
    "minSize": "",
    "maxSize": "",
    "desiredSize": ""
  },
  "updateConfig": {
    "maxUnavailable": "",
    "maxUnavailablePercentage": ""
  },
  "clientRequestToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"labels\": {\n    \"addOrUpdateLabels\": \"\",\n    \"removeLabels\": \"\"\n  },\n  \"taints\": {\n    \"addOrUpdateTaints\": \"\",\n    \"removeTaints\": \"\"\n  },\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"labels\": {\n    \"addOrUpdateLabels\": \"\",\n    \"removeLabels\": \"\"\n  },\n  \"taints\": {\n    \"addOrUpdateTaints\": \"\",\n    \"removeTaints\": \"\"\n  },\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"labels\": {\n    \"addOrUpdateLabels\": \"\",\n    \"removeLabels\": \"\"\n  },\n  \"taints\": {\n    \"addOrUpdateTaints\": \"\",\n    \"removeTaints\": \"\"\n  },\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config")
  .header("content-type", "application/json")
  .body("{\n  \"labels\": {\n    \"addOrUpdateLabels\": \"\",\n    \"removeLabels\": \"\"\n  },\n  \"taints\": {\n    \"addOrUpdateTaints\": \"\",\n    \"removeTaints\": \"\"\n  },\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  labels: {
    addOrUpdateLabels: '',
    removeLabels: ''
  },
  taints: {
    addOrUpdateTaints: '',
    removeTaints: ''
  },
  scalingConfig: {
    minSize: '',
    maxSize: '',
    desiredSize: ''
  },
  updateConfig: {
    maxUnavailable: '',
    maxUnavailablePercentage: ''
  },
  clientRequestToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config',
  headers: {'content-type': 'application/json'},
  data: {
    labels: {addOrUpdateLabels: '', removeLabels: ''},
    taints: {addOrUpdateTaints: '', removeTaints: ''},
    scalingConfig: {minSize: '', maxSize: '', desiredSize: ''},
    updateConfig: {maxUnavailable: '', maxUnavailablePercentage: ''},
    clientRequestToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"labels":{"addOrUpdateLabels":"","removeLabels":""},"taints":{"addOrUpdateTaints":"","removeTaints":""},"scalingConfig":{"minSize":"","maxSize":"","desiredSize":""},"updateConfig":{"maxUnavailable":"","maxUnavailablePercentage":""},"clientRequestToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "labels": {\n    "addOrUpdateLabels": "",\n    "removeLabels": ""\n  },\n  "taints": {\n    "addOrUpdateTaints": "",\n    "removeTaints": ""\n  },\n  "scalingConfig": {\n    "minSize": "",\n    "maxSize": "",\n    "desiredSize": ""\n  },\n  "updateConfig": {\n    "maxUnavailable": "",\n    "maxUnavailablePercentage": ""\n  },\n  "clientRequestToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"labels\": {\n    \"addOrUpdateLabels\": \"\",\n    \"removeLabels\": \"\"\n  },\n  \"taints\": {\n    \"addOrUpdateTaints\": \"\",\n    \"removeTaints\": \"\"\n  },\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config")
  .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/clusters/:name/node-groups/:nodegroupName/update-config',
  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({
  labels: {addOrUpdateLabels: '', removeLabels: ''},
  taints: {addOrUpdateTaints: '', removeTaints: ''},
  scalingConfig: {minSize: '', maxSize: '', desiredSize: ''},
  updateConfig: {maxUnavailable: '', maxUnavailablePercentage: ''},
  clientRequestToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config',
  headers: {'content-type': 'application/json'},
  body: {
    labels: {addOrUpdateLabels: '', removeLabels: ''},
    taints: {addOrUpdateTaints: '', removeTaints: ''},
    scalingConfig: {minSize: '', maxSize: '', desiredSize: ''},
    updateConfig: {maxUnavailable: '', maxUnavailablePercentage: ''},
    clientRequestToken: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  labels: {
    addOrUpdateLabels: '',
    removeLabels: ''
  },
  taints: {
    addOrUpdateTaints: '',
    removeTaints: ''
  },
  scalingConfig: {
    minSize: '',
    maxSize: '',
    desiredSize: ''
  },
  updateConfig: {
    maxUnavailable: '',
    maxUnavailablePercentage: ''
  },
  clientRequestToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config',
  headers: {'content-type': 'application/json'},
  data: {
    labels: {addOrUpdateLabels: '', removeLabels: ''},
    taints: {addOrUpdateTaints: '', removeTaints: ''},
    scalingConfig: {minSize: '', maxSize: '', desiredSize: ''},
    updateConfig: {maxUnavailable: '', maxUnavailablePercentage: ''},
    clientRequestToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"labels":{"addOrUpdateLabels":"","removeLabels":""},"taints":{"addOrUpdateTaints":"","removeTaints":""},"scalingConfig":{"minSize":"","maxSize":"","desiredSize":""},"updateConfig":{"maxUnavailable":"","maxUnavailablePercentage":""},"clientRequestToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"labels": @{ @"addOrUpdateLabels": @"", @"removeLabels": @"" },
                              @"taints": @{ @"addOrUpdateTaints": @"", @"removeTaints": @"" },
                              @"scalingConfig": @{ @"minSize": @"", @"maxSize": @"", @"desiredSize": @"" },
                              @"updateConfig": @{ @"maxUnavailable": @"", @"maxUnavailablePercentage": @"" },
                              @"clientRequestToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config"]
                                                       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}}/clusters/:name/node-groups/:nodegroupName/update-config" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"labels\": {\n    \"addOrUpdateLabels\": \"\",\n    \"removeLabels\": \"\"\n  },\n  \"taints\": {\n    \"addOrUpdateTaints\": \"\",\n    \"removeTaints\": \"\"\n  },\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config",
  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([
    'labels' => [
        'addOrUpdateLabels' => '',
        'removeLabels' => ''
    ],
    'taints' => [
        'addOrUpdateTaints' => '',
        'removeTaints' => ''
    ],
    'scalingConfig' => [
        'minSize' => '',
        'maxSize' => '',
        'desiredSize' => ''
    ],
    'updateConfig' => [
        'maxUnavailable' => '',
        'maxUnavailablePercentage' => ''
    ],
    'clientRequestToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config', [
  'body' => '{
  "labels": {
    "addOrUpdateLabels": "",
    "removeLabels": ""
  },
  "taints": {
    "addOrUpdateTaints": "",
    "removeTaints": ""
  },
  "scalingConfig": {
    "minSize": "",
    "maxSize": "",
    "desiredSize": ""
  },
  "updateConfig": {
    "maxUnavailable": "",
    "maxUnavailablePercentage": ""
  },
  "clientRequestToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'labels' => [
    'addOrUpdateLabels' => '',
    'removeLabels' => ''
  ],
  'taints' => [
    'addOrUpdateTaints' => '',
    'removeTaints' => ''
  ],
  'scalingConfig' => [
    'minSize' => '',
    'maxSize' => '',
    'desiredSize' => ''
  ],
  'updateConfig' => [
    'maxUnavailable' => '',
    'maxUnavailablePercentage' => ''
  ],
  'clientRequestToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'labels' => [
    'addOrUpdateLabels' => '',
    'removeLabels' => ''
  ],
  'taints' => [
    'addOrUpdateTaints' => '',
    'removeTaints' => ''
  ],
  'scalingConfig' => [
    'minSize' => '',
    'maxSize' => '',
    'desiredSize' => ''
  ],
  'updateConfig' => [
    'maxUnavailable' => '',
    'maxUnavailablePercentage' => ''
  ],
  'clientRequestToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config');
$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}}/clusters/:name/node-groups/:nodegroupName/update-config' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "labels": {
    "addOrUpdateLabels": "",
    "removeLabels": ""
  },
  "taints": {
    "addOrUpdateTaints": "",
    "removeTaints": ""
  },
  "scalingConfig": {
    "minSize": "",
    "maxSize": "",
    "desiredSize": ""
  },
  "updateConfig": {
    "maxUnavailable": "",
    "maxUnavailablePercentage": ""
  },
  "clientRequestToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "labels": {
    "addOrUpdateLabels": "",
    "removeLabels": ""
  },
  "taints": {
    "addOrUpdateTaints": "",
    "removeTaints": ""
  },
  "scalingConfig": {
    "minSize": "",
    "maxSize": "",
    "desiredSize": ""
  },
  "updateConfig": {
    "maxUnavailable": "",
    "maxUnavailablePercentage": ""
  },
  "clientRequestToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"labels\": {\n    \"addOrUpdateLabels\": \"\",\n    \"removeLabels\": \"\"\n  },\n  \"taints\": {\n    \"addOrUpdateTaints\": \"\",\n    \"removeTaints\": \"\"\n  },\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/clusters/:name/node-groups/:nodegroupName/update-config", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config"

payload = {
    "labels": {
        "addOrUpdateLabels": "",
        "removeLabels": ""
    },
    "taints": {
        "addOrUpdateTaints": "",
        "removeTaints": ""
    },
    "scalingConfig": {
        "minSize": "",
        "maxSize": "",
        "desiredSize": ""
    },
    "updateConfig": {
        "maxUnavailable": "",
        "maxUnavailablePercentage": ""
    },
    "clientRequestToken": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config"

payload <- "{\n  \"labels\": {\n    \"addOrUpdateLabels\": \"\",\n    \"removeLabels\": \"\"\n  },\n  \"taints\": {\n    \"addOrUpdateTaints\": \"\",\n    \"removeTaints\": \"\"\n  },\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config")

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  \"labels\": {\n    \"addOrUpdateLabels\": \"\",\n    \"removeLabels\": \"\"\n  },\n  \"taints\": {\n    \"addOrUpdateTaints\": \"\",\n    \"removeTaints\": \"\"\n  },\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/clusters/:name/node-groups/:nodegroupName/update-config') do |req|
  req.body = "{\n  \"labels\": {\n    \"addOrUpdateLabels\": \"\",\n    \"removeLabels\": \"\"\n  },\n  \"taints\": {\n    \"addOrUpdateTaints\": \"\",\n    \"removeTaints\": \"\"\n  },\n  \"scalingConfig\": {\n    \"minSize\": \"\",\n    \"maxSize\": \"\",\n    \"desiredSize\": \"\"\n  },\n  \"updateConfig\": {\n    \"maxUnavailable\": \"\",\n    \"maxUnavailablePercentage\": \"\"\n  },\n  \"clientRequestToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config";

    let payload = json!({
        "labels": json!({
            "addOrUpdateLabels": "",
            "removeLabels": ""
        }),
        "taints": json!({
            "addOrUpdateTaints": "",
            "removeTaints": ""
        }),
        "scalingConfig": json!({
            "minSize": "",
            "maxSize": "",
            "desiredSize": ""
        }),
        "updateConfig": json!({
            "maxUnavailable": "",
            "maxUnavailablePercentage": ""
        }),
        "clientRequestToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "labels": {
    "addOrUpdateLabels": "",
    "removeLabels": ""
  },
  "taints": {
    "addOrUpdateTaints": "",
    "removeTaints": ""
  },
  "scalingConfig": {
    "minSize": "",
    "maxSize": "",
    "desiredSize": ""
  },
  "updateConfig": {
    "maxUnavailable": "",
    "maxUnavailablePercentage": ""
  },
  "clientRequestToken": ""
}' |  \
  http POST {{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "labels": {\n    "addOrUpdateLabels": "",\n    "removeLabels": ""\n  },\n  "taints": {\n    "addOrUpdateTaints": "",\n    "removeTaints": ""\n  },\n  "scalingConfig": {\n    "minSize": "",\n    "maxSize": "",\n    "desiredSize": ""\n  },\n  "updateConfig": {\n    "maxUnavailable": "",\n    "maxUnavailablePercentage": ""\n  },\n  "clientRequestToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "labels": [
    "addOrUpdateLabels": "",
    "removeLabels": ""
  ],
  "taints": [
    "addOrUpdateTaints": "",
    "removeTaints": ""
  ],
  "scalingConfig": [
    "minSize": "",
    "maxSize": "",
    "desiredSize": ""
  ],
  "updateConfig": [
    "maxUnavailable": "",
    "maxUnavailablePercentage": ""
  ],
  "clientRequestToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-config")! 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}}/clusters/:name/node-groups/:nodegroupName/update-version");

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  \"version\": \"\",\n  \"releaseVersion\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"force\": false,\n  \"clientRequestToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version" {:content-type :json
                                                                                                     :form-params {:version ""
                                                                                                                   :releaseVersion ""
                                                                                                                   :launchTemplate {:name ""
                                                                                                                                    :version ""
                                                                                                                                    :id ""}
                                                                                                                   :force false
                                                                                                                   :clientRequestToken ""}})

require "http/client"

url = "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"version\": \"\",\n  \"releaseVersion\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"force\": false,\n  \"clientRequestToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version"),
    Content = new StringContent("{\n  \"version\": \"\",\n  \"releaseVersion\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"force\": false,\n  \"clientRequestToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"version\": \"\",\n  \"releaseVersion\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"force\": false,\n  \"clientRequestToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version"

	payload := strings.NewReader("{\n  \"version\": \"\",\n  \"releaseVersion\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"force\": false,\n  \"clientRequestToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/clusters/:name/node-groups/:nodegroupName/update-version HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 164

{
  "version": "",
  "releaseVersion": "",
  "launchTemplate": {
    "name": "",
    "version": "",
    "id": ""
  },
  "force": false,
  "clientRequestToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"version\": \"\",\n  \"releaseVersion\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"force\": false,\n  \"clientRequestToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"version\": \"\",\n  \"releaseVersion\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"force\": false,\n  \"clientRequestToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"version\": \"\",\n  \"releaseVersion\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"force\": false,\n  \"clientRequestToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version")
  .header("content-type", "application/json")
  .body("{\n  \"version\": \"\",\n  \"releaseVersion\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"force\": false,\n  \"clientRequestToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  version: '',
  releaseVersion: '',
  launchTemplate: {
    name: '',
    version: '',
    id: ''
  },
  force: false,
  clientRequestToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version',
  headers: {'content-type': 'application/json'},
  data: {
    version: '',
    releaseVersion: '',
    launchTemplate: {name: '', version: '', id: ''},
    force: false,
    clientRequestToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"version":"","releaseVersion":"","launchTemplate":{"name":"","version":"","id":""},"force":false,"clientRequestToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "version": "",\n  "releaseVersion": "",\n  "launchTemplate": {\n    "name": "",\n    "version": "",\n    "id": ""\n  },\n  "force": false,\n  "clientRequestToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"version\": \"\",\n  \"releaseVersion\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"force\": false,\n  \"clientRequestToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version")
  .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/clusters/:name/node-groups/:nodegroupName/update-version',
  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({
  version: '',
  releaseVersion: '',
  launchTemplate: {name: '', version: '', id: ''},
  force: false,
  clientRequestToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version',
  headers: {'content-type': 'application/json'},
  body: {
    version: '',
    releaseVersion: '',
    launchTemplate: {name: '', version: '', id: ''},
    force: false,
    clientRequestToken: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  version: '',
  releaseVersion: '',
  launchTemplate: {
    name: '',
    version: '',
    id: ''
  },
  force: false,
  clientRequestToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version',
  headers: {'content-type': 'application/json'},
  data: {
    version: '',
    releaseVersion: '',
    launchTemplate: {name: '', version: '', id: ''},
    force: false,
    clientRequestToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"version":"","releaseVersion":"","launchTemplate":{"name":"","version":"","id":""},"force":false,"clientRequestToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"version": @"",
                              @"releaseVersion": @"",
                              @"launchTemplate": @{ @"name": @"", @"version": @"", @"id": @"" },
                              @"force": @NO,
                              @"clientRequestToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version"]
                                                       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}}/clusters/:name/node-groups/:nodegroupName/update-version" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"version\": \"\",\n  \"releaseVersion\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"force\": false,\n  \"clientRequestToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version",
  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([
    'version' => '',
    'releaseVersion' => '',
    'launchTemplate' => [
        'name' => '',
        'version' => '',
        'id' => ''
    ],
    'force' => null,
    'clientRequestToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version', [
  'body' => '{
  "version": "",
  "releaseVersion": "",
  "launchTemplate": {
    "name": "",
    "version": "",
    "id": ""
  },
  "force": false,
  "clientRequestToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'version' => '',
  'releaseVersion' => '',
  'launchTemplate' => [
    'name' => '',
    'version' => '',
    'id' => ''
  ],
  'force' => null,
  'clientRequestToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'version' => '',
  'releaseVersion' => '',
  'launchTemplate' => [
    'name' => '',
    'version' => '',
    'id' => ''
  ],
  'force' => null,
  'clientRequestToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version');
$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}}/clusters/:name/node-groups/:nodegroupName/update-version' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "version": "",
  "releaseVersion": "",
  "launchTemplate": {
    "name": "",
    "version": "",
    "id": ""
  },
  "force": false,
  "clientRequestToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "version": "",
  "releaseVersion": "",
  "launchTemplate": {
    "name": "",
    "version": "",
    "id": ""
  },
  "force": false,
  "clientRequestToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"version\": \"\",\n  \"releaseVersion\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"force\": false,\n  \"clientRequestToken\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/clusters/:name/node-groups/:nodegroupName/update-version", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version"

payload = {
    "version": "",
    "releaseVersion": "",
    "launchTemplate": {
        "name": "",
        "version": "",
        "id": ""
    },
    "force": False,
    "clientRequestToken": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version"

payload <- "{\n  \"version\": \"\",\n  \"releaseVersion\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"force\": false,\n  \"clientRequestToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version")

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  \"version\": \"\",\n  \"releaseVersion\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"force\": false,\n  \"clientRequestToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/clusters/:name/node-groups/:nodegroupName/update-version') do |req|
  req.body = "{\n  \"version\": \"\",\n  \"releaseVersion\": \"\",\n  \"launchTemplate\": {\n    \"name\": \"\",\n    \"version\": \"\",\n    \"id\": \"\"\n  },\n  \"force\": false,\n  \"clientRequestToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version";

    let payload = json!({
        "version": "",
        "releaseVersion": "",
        "launchTemplate": json!({
            "name": "",
            "version": "",
            "id": ""
        }),
        "force": false,
        "clientRequestToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "version": "",
  "releaseVersion": "",
  "launchTemplate": {
    "name": "",
    "version": "",
    "id": ""
  },
  "force": false,
  "clientRequestToken": ""
}' |  \
  http POST {{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "version": "",\n  "releaseVersion": "",\n  "launchTemplate": {\n    "name": "",\n    "version": "",\n    "id": ""\n  },\n  "force": false,\n  "clientRequestToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "version": "",
  "releaseVersion": "",
  "launchTemplate": [
    "name": "",
    "version": "",
    "id": ""
  ],
  "force": false,
  "clientRequestToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clusters/:name/node-groups/:nodegroupName/update-version")! 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()