Renku Data Services APIvv1

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resource_pools/:resource_pool_id/classes");

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  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/resource_pools/:resource_pool_id/classes" {:content-type :json
                                                                                     :form-params {:name ""
                                                                                                   :cpu ""
                                                                                                   :memory 0
                                                                                                   :gpu 0
                                                                                                   :max_storage 0
                                                                                                   :default_storage 0
                                                                                                   :default false
                                                                                                   :tolerations []
                                                                                                   :node_affinities [{:key ""
                                                                                                                      :required_during_scheduling false}]}})

require "http/client"

url = "{{baseUrl}}/resource_pools/:resource_pool_id/classes"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/resource_pools/:resource_pool_id/classes"),
    Content = new StringContent("{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/resource_pools/:resource_pool_id/classes");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/resource_pools/:resource_pool_id/classes"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}")

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

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

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

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

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

}

POST /baseUrl/resource_pools/:resource_pool_id/classes HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 240

{
  "name": "",
  "cpu": "",
  "memory": 0,
  "gpu": 0,
  "max_storage": 0,
  "default_storage": 0,
  "default": false,
  "tolerations": [],
  "node_affinities": [
    {
      "key": "",
      "required_during_scheduling": false
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/resource_pools/:resource_pool_id/classes")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resource_pools/:resource_pool_id/classes"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/classes")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/resource_pools/:resource_pool_id/classes")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  cpu: '',
  memory: 0,
  gpu: 0,
  max_storage: 0,
  default_storage: 0,
  default: false,
  tolerations: [],
  node_affinities: [
    {
      key: '',
      required_during_scheduling: false
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/resource_pools/:resource_pool_id/classes');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    cpu: '',
    memory: 0,
    gpu: 0,
    max_storage: 0,
    default_storage: 0,
    default: false,
    tolerations: [],
    node_affinities: [{key: '', required_during_scheduling: false}]
  }
};

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

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/classes';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","cpu":"","memory":0,"gpu":0,"max_storage":0,"default_storage":0,"default":false,"tolerations":[],"node_affinities":[{"key":"","required_during_scheduling":false}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "cpu": "",\n  "memory": 0,\n  "gpu": 0,\n  "max_storage": 0,\n  "default_storage": 0,\n  "default": false,\n  "tolerations": [],\n  "node_affinities": [\n    {\n      "key": "",\n      "required_during_scheduling": false\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/classes")
  .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/resource_pools/:resource_pool_id/classes',
  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: '',
  cpu: '',
  memory: 0,
  gpu: 0,
  max_storage: 0,
  default_storage: 0,
  default: false,
  tolerations: [],
  node_affinities: [{key: '', required_during_scheduling: false}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes',
  headers: {'content-type': 'application/json'},
  body: {
    name: '',
    cpu: '',
    memory: 0,
    gpu: 0,
    max_storage: 0,
    default_storage: 0,
    default: false,
    tolerations: [],
    node_affinities: [{key: '', required_during_scheduling: false}]
  },
  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}}/resource_pools/:resource_pool_id/classes');

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

req.type('json');
req.send({
  name: '',
  cpu: '',
  memory: 0,
  gpu: 0,
  max_storage: 0,
  default_storage: 0,
  default: false,
  tolerations: [],
  node_affinities: [
    {
      key: '',
      required_during_scheduling: false
    }
  ]
});

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}}/resource_pools/:resource_pool_id/classes',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    cpu: '',
    memory: 0,
    gpu: 0,
    max_storage: 0,
    default_storage: 0,
    default: false,
    tolerations: [],
    node_affinities: [{key: '', required_during_scheduling: false}]
  }
};

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

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

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/classes';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","cpu":"","memory":0,"gpu":0,"max_storage":0,"default_storage":0,"default":false,"tolerations":[],"node_affinities":[{"key":"","required_during_scheduling":false}]}'
};

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": @"",
                              @"cpu": @"",
                              @"memory": @0,
                              @"gpu": @0,
                              @"max_storage": @0,
                              @"default_storage": @0,
                              @"default": @NO,
                              @"tolerations": @[  ],
                              @"node_affinities": @[ @{ @"key": @"", @"required_during_scheduling": @NO } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resource_pools/:resource_pool_id/classes"]
                                                       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}}/resource_pools/:resource_pool_id/classes" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}" in

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

 "{{baseUrl}}/resource_pools/:resource_pool_id/classes",
  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' => '',
    'cpu' => '',
    'memory' => 0,
    'gpu' => 0,
    'max_storage' => 0,
    'default_storage' => 0,
    'default' => null,
    'tolerations' => [
        
    ],
    'node_affinities' => [
        [
                'key' => '',
                'required_during_scheduling' => null
        ]
    ]
  ]),
  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}}/resource_pools/:resource_pool_id/classes', [
  'body' => '{
  "name": "",
  "cpu": "",
  "memory": 0,
  "gpu": 0,
  "max_storage": 0,
  "default_storage": 0,
  "default": false,
  "tolerations": [],
  "node_affinities": [
    {
      "key": "",
      "required_during_scheduling": false
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resource_pools/:resource_pool_id/classes');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'cpu' => '',
  'memory' => 0,
  'gpu' => 0,
  'max_storage' => 0,
  'default_storage' => 0,
  'default' => null,
  'tolerations' => [
    
  ],
  'node_affinities' => [
    [
        'key' => '',
        'required_during_scheduling' => null
    ]
  ]
]));

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

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

append(json_encode([
  'name' => '',
  'cpu' => '',
  'memory' => 0,
  'gpu' => 0,
  'max_storage' => 0,
  'default_storage' => 0,
  'default' => null,
  'tolerations' => [
    
  ],
  'node_affinities' => [
    [
        'key' => '',
        'required_during_scheduling' => null
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/resource_pools/:resource_pool_id/classes');
$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}}/resource_pools/:resource_pool_id/classes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "cpu": "",
  "memory": 0,
  "gpu": 0,
  "max_storage": 0,
  "default_storage": 0,
  "default": false,
  "tolerations": [],
  "node_affinities": [
    {
      "key": "",
      "required_during_scheduling": false
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/classes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "cpu": "",
  "memory": 0,
  "gpu": 0,
  "max_storage": 0,
  "default_storage": 0,
  "default": false,
  "tolerations": [],
  "node_affinities": [
    {
      "key": "",
      "required_during_scheduling": false
    }
  ]
}'

import http.client

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

payload = "{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/resource_pools/:resource_pool_id/classes", payload, headers)

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

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

import requests

url = "{{baseUrl}}/resource_pools/:resource_pool_id/classes"

payload = {
    "name": "",
    "cpu": "",
    "memory": 0,
    "gpu": 0,
    "max_storage": 0,
    "default_storage": 0,
    "default": False,
    "tolerations": [],
    "node_affinities": [
        {
            "key": "",
            "required_during_scheduling": False
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource_pools/:resource_pool_id/classes"

payload <- "{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource_pools/:resource_pool_id/classes")

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  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/resource_pools/:resource_pool_id/classes') do |req|
  req.body = "{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "name": "",
        "cpu": "",
        "memory": 0,
        "gpu": 0,
        "max_storage": 0,
        "default_storage": 0,
        "default": false,
        "tolerations": (),
        "node_affinities": (
            json!({
                "key": "",
                "required_during_scheduling": false
            })
        )
    });

    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": "",
  "cpu": "",
  "memory": 0,
  "gpu": 0,
  "max_storage": 0,
  "default_storage": 0,
  "default": false,
  "tolerations": [],
  "node_affinities": [
    {
      "key": "",
      "required_during_scheduling": false
    }
  ]
}' |  \
  http POST {{baseUrl}}/resource_pools/:resource_pool_id/classes \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "cpu": "",\n  "memory": 0,\n  "gpu": 0,\n  "max_storage": 0,\n  "default_storage": 0,\n  "default": false,\n  "tolerations": [],\n  "node_affinities": [\n    {\n      "key": "",\n      "required_during_scheduling": false\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/resource_pools/:resource_pool_id/classes

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "name": "",
  "cpu": "",
  "memory": 0,
  "gpu": 0,
  "max_storage": 0,
  "default_storage": 0,
  "default": false,
  "tolerations": [],
  "node_affinities": [
    [
      "key": "",
      "required_during_scheduling": false
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resource_pools/:resource_pool_id/classes")! 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}}/resource_pools/:resource_pool_id/classes/:class_id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id")

require "http/client"

url = "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id"

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

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

var client = new RestClient("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id"

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

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

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

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

}

GET /baseUrl/resource_pools/:resource_pool_id/classes/:class_id HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id'
};

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

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource_pools/:resource_pool_id/classes/:class_id',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id'
};

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

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

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id" in

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

 "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id');

echo $response->getBody();

setUrl('{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/resource_pools/:resource_pool_id/classes/:class_id")

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

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

import requests

url = "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/resource_pools/:resource_pool_id/classes/:class_id') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id")! 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}}/classes/:class_id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/classes/:class_id")

require "http/client"

url = "{{baseUrl}}/classes/:class_id"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/classes/:class_id"

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/classes/:class_id'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/classes/:class_id');

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

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

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

const options = {method: 'GET', url: '{{baseUrl}}/classes/:class_id'};

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

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

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

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

 "{{baseUrl}}/classes/:class_id",
  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}}/classes/:class_id');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/classes/:class_id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/classes/:class_id' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/classes/:class_id")

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

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

import requests

url = "{{baseUrl}}/classes/:class_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/classes/:class_id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/classes/:class_id")

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/classes/:class_id') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/classes/:class_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/classes/:class_id

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resource_pools/:resource_pool_id/classes");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/resource_pools/:resource_pool_id/classes")

require "http/client"

url = "{{baseUrl}}/resource_pools/:resource_pool_id/classes"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/resource_pools/:resource_pool_id/classes"

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

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

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

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

}

GET /baseUrl/resource_pools/:resource_pool_id/classes HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/classes")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/resource_pools/:resource_pool_id/classes")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/resource_pools/:resource_pool_id/classes');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes'
};

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

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/classes';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/classes")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource_pools/:resource_pool_id/classes',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/resource_pools/:resource_pool_id/classes');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes'
};

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

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

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/classes';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resource_pools/:resource_pool_id/classes"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resource_pools/:resource_pool_id/classes" in

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

 "{{baseUrl}}/resource_pools/:resource_pool_id/classes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/resource_pools/:resource_pool_id/classes');

echo $response->getBody();

setUrl('{{baseUrl}}/resource_pools/:resource_pool_id/classes');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/classes' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/classes' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/resource_pools/:resource_pool_id/classes")

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

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

import requests

url = "{{baseUrl}}/resource_pools/:resource_pool_id/classes"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource_pools/:resource_pool_id/classes"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource_pools/:resource_pool_id/classes")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/resource_pools/:resource_pool_id/classes') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/resource_pools/:resource_pool_id/classes

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/resource_pools/:resource_pool_id/classes

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities")

require "http/client"

url = "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities"

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

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

var client = new RestClient("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities"

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

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

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

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

}

GET /baseUrl/resource_pools/:resource_pool_id/classes/:class_id/node_affinities HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities'
};

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

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource_pools/:resource_pool_id/classes/:class_id/node_affinities',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities'
};

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

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

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities" in

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

 "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities');

echo $response->getBody();

setUrl('{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/resource_pools/:resource_pool_id/classes/:class_id/node_affinities")

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

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

import requests

url = "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/resource_pools/:resource_pool_id/classes/:class_id/node_affinities') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations")

require "http/client"

url = "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations"

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

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

var client = new RestClient("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations"

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

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

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

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

}

GET /baseUrl/resource_pools/:resource_pool_id/classes/:class_id/tolerations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations'
};

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

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource_pools/:resource_pool_id/classes/:class_id/tolerations',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations'
};

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

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

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations" in

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

 "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations');

echo $response->getBody();

setUrl('{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/resource_pools/:resource_pool_id/classes/:class_id/tolerations")

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

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

import requests

url = "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/resource_pools/:resource_pool_id/classes/:class_id/tolerations') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id");

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  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id" {:content-type :json
                                                                                                :form-params {:name ""
                                                                                                              :cpu ""
                                                                                                              :memory 0
                                                                                                              :gpu 0
                                                                                                              :max_storage 0
                                                                                                              :default_storage 0
                                                                                                              :default false
                                                                                                              :tolerations []
                                                                                                              :node_affinities [{:key ""
                                                                                                                                 :required_during_scheduling false}]}})

require "http/client"

url = "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id"),
    Content = new StringContent("{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}")

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

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

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

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

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

}

PATCH /baseUrl/resource_pools/:resource_pool_id/classes/:class_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 240

{
  "name": "",
  "cpu": "",
  "memory": 0,
  "gpu": 0,
  "max_storage": 0,
  "default_storage": 0,
  "default": false,
  "tolerations": [],
  "node_affinities": [
    {
      "key": "",
      "required_during_scheduling": false
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  cpu: '',
  memory: 0,
  gpu: 0,
  max_storage: 0,
  default_storage: 0,
  default: false,
  tolerations: [],
  node_affinities: [
    {
      key: '',
      required_during_scheduling: false
    }
  ]
});

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

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

xhr.open('PATCH', '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    cpu: '',
    memory: 0,
    gpu: 0,
    max_storage: 0,
    default_storage: 0,
    default: false,
    tolerations: [],
    node_affinities: [{key: '', required_during_scheduling: false}]
  }
};

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

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","cpu":"","memory":0,"gpu":0,"max_storage":0,"default_storage":0,"default":false,"tolerations":[],"node_affinities":[{"key":"","required_during_scheduling":false}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "cpu": "",\n  "memory": 0,\n  "gpu": 0,\n  "max_storage": 0,\n  "default_storage": 0,\n  "default": false,\n  "tolerations": [],\n  "node_affinities": [\n    {\n      "key": "",\n      "required_during_scheduling": false\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource_pools/:resource_pool_id/classes/:class_id',
  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: '',
  cpu: '',
  memory: 0,
  gpu: 0,
  max_storage: 0,
  default_storage: 0,
  default: false,
  tolerations: [],
  node_affinities: [{key: '', required_during_scheduling: false}]
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id',
  headers: {'content-type': 'application/json'},
  body: {
    name: '',
    cpu: '',
    memory: 0,
    gpu: 0,
    max_storage: 0,
    default_storage: 0,
    default: false,
    tolerations: [],
    node_affinities: [{key: '', required_during_scheduling: false}]
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id');

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

req.type('json');
req.send({
  name: '',
  cpu: '',
  memory: 0,
  gpu: 0,
  max_storage: 0,
  default_storage: 0,
  default: false,
  tolerations: [],
  node_affinities: [
    {
      key: '',
      required_during_scheduling: false
    }
  ]
});

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    cpu: '',
    memory: 0,
    gpu: 0,
    max_storage: 0,
    default_storage: 0,
    default: false,
    tolerations: [],
    node_affinities: [{key: '', required_during_scheduling: false}]
  }
};

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

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

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","cpu":"","memory":0,"gpu":0,"max_storage":0,"default_storage":0,"default":false,"tolerations":[],"node_affinities":[{"key":"","required_during_scheduling":false}]}'
};

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": @"",
                              @"cpu": @"",
                              @"memory": @0,
                              @"gpu": @0,
                              @"max_storage": @0,
                              @"default_storage": @0,
                              @"default": @NO,
                              @"tolerations": @[  ],
                              @"node_affinities": @[ @{ @"key": @"", @"required_during_scheduling": @NO } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}" in

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

 "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => '',
    'cpu' => '',
    'memory' => 0,
    'gpu' => 0,
    'max_storage' => 0,
    'default_storage' => 0,
    'default' => null,
    'tolerations' => [
        
    ],
    'node_affinities' => [
        [
                'key' => '',
                'required_during_scheduling' => null
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PATCH', '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id', [
  'body' => '{
  "name": "",
  "cpu": "",
  "memory": 0,
  "gpu": 0,
  "max_storage": 0,
  "default_storage": 0,
  "default": false,
  "tolerations": [],
  "node_affinities": [
    {
      "key": "",
      "required_during_scheduling": false
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'cpu' => '',
  'memory' => 0,
  'gpu' => 0,
  'max_storage' => 0,
  'default_storage' => 0,
  'default' => null,
  'tolerations' => [
    
  ],
  'node_affinities' => [
    [
        'key' => '',
        'required_during_scheduling' => null
    ]
  ]
]));

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

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

append(json_encode([
  'name' => '',
  'cpu' => '',
  'memory' => 0,
  'gpu' => 0,
  'max_storage' => 0,
  'default_storage' => 0,
  'default' => null,
  'tolerations' => [
    
  ],
  'node_affinities' => [
    [
        'key' => '',
        'required_during_scheduling' => null
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id');
$request->setRequestMethod('PATCH');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "cpu": "",
  "memory": 0,
  "gpu": 0,
  "max_storage": 0,
  "default_storage": 0,
  "default": false,
  "tolerations": [],
  "node_affinities": [
    {
      "key": "",
      "required_during_scheduling": false
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "cpu": "",
  "memory": 0,
  "gpu": 0,
  "max_storage": 0,
  "default_storage": 0,
  "default": false,
  "tolerations": [],
  "node_affinities": [
    {
      "key": "",
      "required_during_scheduling": false
    }
  ]
}'

import http.client

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

payload = "{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}"

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

conn.request("PATCH", "/baseUrl/resource_pools/:resource_pool_id/classes/:class_id", payload, headers)

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

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

import requests

url = "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id"

payload = {
    "name": "",
    "cpu": "",
    "memory": 0,
    "gpu": 0,
    "max_storage": 0,
    "default_storage": 0,
    "default": False,
    "tolerations": [],
    "node_affinities": [
        {
            "key": "",
            "required_during_scheduling": False
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id"

payload <- "{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.patch('/baseUrl/resource_pools/:resource_pool_id/classes/:class_id') do |req|
  req.body = "{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}"
end

puts response.status
puts response.body

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

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

    let payload = json!({
        "name": "",
        "cpu": "",
        "memory": 0,
        "gpu": 0,
        "max_storage": 0,
        "default_storage": 0,
        "default": false,
        "tolerations": (),
        "node_affinities": (
            json!({
                "key": "",
                "required_during_scheduling": false
            })
        )
    });

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

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

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

    dbg!(results);
}

echo '{
  "name": "",
  "cpu": "",
  "memory": 0,
  "gpu": 0,
  "max_storage": 0,
  "default_storage": 0,
  "default": false,
  "tolerations": [],
  "node_affinities": [
    {
      "key": "",
      "required_during_scheduling": false
    }
  ]
}' |  \
  http PATCH {{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "cpu": "",\n  "memory": 0,\n  "gpu": 0,\n  "max_storage": 0,\n  "default_storage": 0,\n  "default": false,\n  "tolerations": [],\n  "node_affinities": [\n    {\n      "key": "",\n      "required_during_scheduling": false\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "name": "",
  "cpu": "",
  "memory": 0,
  "gpu": 0,
  "max_storage": 0,
  "default_storage": 0,
  "default": false,
  "tolerations": [],
  "node_affinities": [
    [
      "key": "",
      "required_during_scheduling": false
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities")

require "http/client"

url = "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities"

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

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

var client = new RestClient("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities"

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

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

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

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

}

DELETE /baseUrl/resource_pools/:resource_pool_id/classes/:class_id/node_affinities HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities'
};

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

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource_pools/:resource_pool_id/classes/:class_id/node_affinities',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities'
};

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

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

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities" in

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

 "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities');

echo $response->getBody();

setUrl('{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/resource_pools/:resource_pool_id/classes/:class_id/node_affinities")

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

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

import requests

url = "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/resource_pools/:resource_pool_id/classes/:class_id/node_affinities') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities";

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/node_affinities")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations")

require "http/client"

url = "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations"

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

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

var client = new RestClient("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations"

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

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

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

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

}

DELETE /baseUrl/resource_pools/:resource_pool_id/classes/:class_id/tolerations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations'
};

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

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource_pools/:resource_pool_id/classes/:class_id/tolerations',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations'
};

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

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

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations" in

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

 "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations');

echo $response->getBody();

setUrl('{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/resource_pools/:resource_pool_id/classes/:class_id/tolerations")

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

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

import requests

url = "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/resource_pools/:resource_pool_id/classes/:class_id/tolerations') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations";

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id/tolerations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id")

require "http/client"

url = "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id"

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

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

var client = new RestClient("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id"

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

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

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

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

}

DELETE /baseUrl/resource_pools/:resource_pool_id/classes/:class_id HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id'
};

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

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource_pools/:resource_pool_id/classes/:class_id',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id'
};

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

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

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id" in

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

 "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id');

echo $response->getBody();

setUrl('{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/resource_pools/:resource_pool_id/classes/:class_id")

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

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

import requests

url = "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/resource_pools/:resource_pool_id/classes/:class_id') do |req|
end

puts response.status
puts response.body

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

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

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id")! 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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id");

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  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id" {:content-type :json
                                                                                              :form-params {:name ""
                                                                                                            :cpu ""
                                                                                                            :memory 0
                                                                                                            :gpu 0
                                                                                                            :max_storage 0
                                                                                                            :default_storage 0
                                                                                                            :default false
                                                                                                            :tolerations []
                                                                                                            :node_affinities [{:key ""
                                                                                                                               :required_during_scheduling false}]}})

require "http/client"

url = "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id"),
    Content = new StringContent("{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}")

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

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

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

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

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

}

PUT /baseUrl/resource_pools/:resource_pool_id/classes/:class_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 240

{
  "name": "",
  "cpu": "",
  "memory": 0,
  "gpu": 0,
  "max_storage": 0,
  "default_storage": 0,
  "default": false,
  "tolerations": [],
  "node_affinities": [
    {
      "key": "",
      "required_during_scheduling": false
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  cpu: '',
  memory: 0,
  gpu: 0,
  max_storage: 0,
  default_storage: 0,
  default: false,
  tolerations: [],
  node_affinities: [
    {
      key: '',
      required_during_scheduling: false
    }
  ]
});

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

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

xhr.open('PUT', '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    cpu: '',
    memory: 0,
    gpu: 0,
    max_storage: 0,
    default_storage: 0,
    default: false,
    tolerations: [],
    node_affinities: [{key: '', required_during_scheduling: false}]
  }
};

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

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","cpu":"","memory":0,"gpu":0,"max_storage":0,"default_storage":0,"default":false,"tolerations":[],"node_affinities":[{"key":"","required_during_scheduling":false}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "cpu": "",\n  "memory": 0,\n  "gpu": 0,\n  "max_storage": 0,\n  "default_storage": 0,\n  "default": false,\n  "tolerations": [],\n  "node_affinities": [\n    {\n      "key": "",\n      "required_during_scheduling": false\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource_pools/:resource_pool_id/classes/:class_id',
  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: '',
  cpu: '',
  memory: 0,
  gpu: 0,
  max_storage: 0,
  default_storage: 0,
  default: false,
  tolerations: [],
  node_affinities: [{key: '', required_during_scheduling: false}]
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id',
  headers: {'content-type': 'application/json'},
  body: {
    name: '',
    cpu: '',
    memory: 0,
    gpu: 0,
    max_storage: 0,
    default_storage: 0,
    default: false,
    tolerations: [],
    node_affinities: [{key: '', required_during_scheduling: false}]
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id');

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

req.type('json');
req.send({
  name: '',
  cpu: '',
  memory: 0,
  gpu: 0,
  max_storage: 0,
  default_storage: 0,
  default: false,
  tolerations: [],
  node_affinities: [
    {
      key: '',
      required_during_scheduling: false
    }
  ]
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    cpu: '',
    memory: 0,
    gpu: 0,
    max_storage: 0,
    default_storage: 0,
    default: false,
    tolerations: [],
    node_affinities: [{key: '', required_during_scheduling: false}]
  }
};

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

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

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","cpu":"","memory":0,"gpu":0,"max_storage":0,"default_storage":0,"default":false,"tolerations":[],"node_affinities":[{"key":"","required_during_scheduling":false}]}'
};

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": @"",
                              @"cpu": @"",
                              @"memory": @0,
                              @"gpu": @0,
                              @"max_storage": @0,
                              @"default_storage": @0,
                              @"default": @NO,
                              @"tolerations": @[  ],
                              @"node_affinities": @[ @{ @"key": @"", @"required_during_scheduling": @NO } ] };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}" in

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

 "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => '',
    'cpu' => '',
    'memory' => 0,
    'gpu' => 0,
    'max_storage' => 0,
    'default_storage' => 0,
    'default' => null,
    'tolerations' => [
        
    ],
    'node_affinities' => [
        [
                'key' => '',
                'required_during_scheduling' => null
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id', [
  'body' => '{
  "name": "",
  "cpu": "",
  "memory": 0,
  "gpu": 0,
  "max_storage": 0,
  "default_storage": 0,
  "default": false,
  "tolerations": [],
  "node_affinities": [
    {
      "key": "",
      "required_during_scheduling": false
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'cpu' => '',
  'memory' => 0,
  'gpu' => 0,
  'max_storage' => 0,
  'default_storage' => 0,
  'default' => null,
  'tolerations' => [
    
  ],
  'node_affinities' => [
    [
        'key' => '',
        'required_during_scheduling' => null
    ]
  ]
]));

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

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

append(json_encode([
  'name' => '',
  'cpu' => '',
  'memory' => 0,
  'gpu' => 0,
  'max_storage' => 0,
  'default_storage' => 0,
  'default' => null,
  'tolerations' => [
    
  ],
  'node_affinities' => [
    [
        'key' => '',
        'required_during_scheduling' => null
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "cpu": "",
  "memory": 0,
  "gpu": 0,
  "max_storage": 0,
  "default_storage": 0,
  "default": false,
  "tolerations": [],
  "node_affinities": [
    {
      "key": "",
      "required_during_scheduling": false
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "cpu": "",
  "memory": 0,
  "gpu": 0,
  "max_storage": 0,
  "default_storage": 0,
  "default": false,
  "tolerations": [],
  "node_affinities": [
    {
      "key": "",
      "required_during_scheduling": false
    }
  ]
}'

import http.client

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

payload = "{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}"

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

conn.request("PUT", "/baseUrl/resource_pools/:resource_pool_id/classes/:class_id", payload, headers)

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

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

import requests

url = "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id"

payload = {
    "name": "",
    "cpu": "",
    "memory": 0,
    "gpu": 0,
    "max_storage": 0,
    "default_storage": 0,
    "default": False,
    "tolerations": [],
    "node_affinities": [
        {
            "key": "",
            "required_during_scheduling": False
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id"

payload <- "{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id")

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.put('/baseUrl/resource_pools/:resource_pool_id/classes/:class_id') do |req|
  req.body = "{\n  \"name\": \"\",\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"max_storage\": 0,\n  \"default_storage\": 0,\n  \"default\": false,\n  \"tolerations\": [],\n  \"node_affinities\": [\n    {\n      \"key\": \"\",\n      \"required_during_scheduling\": false\n    }\n  ]\n}"
end

puts response.status
puts response.body

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

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

    let payload = json!({
        "name": "",
        "cpu": "",
        "memory": 0,
        "gpu": 0,
        "max_storage": 0,
        "default_storage": 0,
        "default": false,
        "tolerations": (),
        "node_affinities": (
            json!({
                "key": "",
                "required_during_scheduling": false
            })
        )
    });

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

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

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

    dbg!(results);
}

echo '{
  "name": "",
  "cpu": "",
  "memory": 0,
  "gpu": 0,
  "max_storage": 0,
  "default_storage": 0,
  "default": false,
  "tolerations": [],
  "node_affinities": [
    {
      "key": "",
      "required_during_scheduling": false
    }
  ]
}' |  \
  http PUT {{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "cpu": "",\n  "memory": 0,\n  "gpu": 0,\n  "max_storage": 0,\n  "default_storage": 0,\n  "default": false,\n  "tolerations": [],\n  "node_affinities": [\n    {\n      "key": "",\n      "required_during_scheduling": false\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/resource_pools/:resource_pool_id/classes/:class_id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "name": "",
  "cpu": "",
  "memory": 0,
  "gpu": 0,
  "max_storage": 0,
  "default_storage": 0,
  "default": false,
  "tolerations": [],
  "node_affinities": [
    [
      "key": "",
      "required_during_scheduling": false
    ]
  ]
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/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  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/clusters" {:content-type :json
                                                     :form-params {:name ""
                                                                   :config_name ""
                                                                   :session_protocol ""
                                                                   :session_host ""
                                                                   :session_port 0
                                                                   :session_path ""
                                                                   :session_ingress_class_name ""
                                                                   :session_ingress_annotations {}
                                                                   :session_tls_secret_name ""
                                                                   :session_storage_class ""
                                                                   :service_account_name ""}})

require "http/client"

url = "{{baseUrl}}/clusters"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/clusters"),
    Content = new StringContent("{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/clusters");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\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  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/clusters HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 295

{
  "name": "",
  "config_name": "",
  "session_protocol": "",
  "session_host": "",
  "session_port": 0,
  "session_path": "",
  "session_ingress_class_name": "",
  "session_ingress_annotations": {},
  "session_tls_secret_name": "",
  "session_storage_class": "",
  "service_account_name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/clusters")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\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  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\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  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  config_name: '',
  session_protocol: '',
  session_host: '',
  session_port: 0,
  session_path: '',
  session_ingress_class_name: '',
  session_ingress_annotations: {},
  session_tls_secret_name: '',
  session_storage_class: '',
  service_account_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');
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: '',
    config_name: '',
    session_protocol: '',
    session_host: '',
    session_port: 0,
    session_path: '',
    session_ingress_class_name: '',
    session_ingress_annotations: {},
    session_tls_secret_name: '',
    session_storage_class: '',
    service_account_name: ''
  }
};

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":"","config_name":"","session_protocol":"","session_host":"","session_port":0,"session_path":"","session_ingress_class_name":"","session_ingress_annotations":{},"session_tls_secret_name":"","session_storage_class":"","service_account_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',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "config_name": "",\n  "session_protocol": "",\n  "session_host": "",\n  "session_port": 0,\n  "session_path": "",\n  "session_ingress_class_name": "",\n  "session_ingress_annotations": {},\n  "session_tls_secret_name": "",\n  "session_storage_class": "",\n  "service_account_name": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\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: '',
  config_name: '',
  session_protocol: '',
  session_host: '',
  session_port: 0,
  session_path: '',
  session_ingress_class_name: '',
  session_ingress_annotations: {},
  session_tls_secret_name: '',
  session_storage_class: '',
  service_account_name: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/clusters',
  headers: {'content-type': 'application/json'},
  body: {
    name: '',
    config_name: '',
    session_protocol: '',
    session_host: '',
    session_port: 0,
    session_path: '',
    session_ingress_class_name: '',
    session_ingress_annotations: {},
    session_tls_secret_name: '',
    session_storage_class: '',
    service_account_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');

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

req.type('json');
req.send({
  name: '',
  config_name: '',
  session_protocol: '',
  session_host: '',
  session_port: 0,
  session_path: '',
  session_ingress_class_name: '',
  session_ingress_annotations: {},
  session_tls_secret_name: '',
  session_storage_class: '',
  service_account_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',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    config_name: '',
    session_protocol: '',
    session_host: '',
    session_port: 0,
    session_path: '',
    session_ingress_class_name: '',
    session_ingress_annotations: {},
    session_tls_secret_name: '',
    session_storage_class: '',
    service_account_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';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","config_name":"","session_protocol":"","session_host":"","session_port":0,"session_path":"","session_ingress_class_name":"","session_ingress_annotations":{},"session_tls_secret_name":"","session_storage_class":"","service_account_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 = @{ @"name": @"",
                              @"config_name": @"",
                              @"session_protocol": @"",
                              @"session_host": @"",
                              @"session_port": @0,
                              @"session_path": @"",
                              @"session_ingress_class_name": @"",
                              @"session_ingress_annotations": @{  },
                              @"session_tls_secret_name": @"",
                              @"session_storage_class": @"",
                              @"service_account_name": @"" };

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  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\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' => '',
    'config_name' => '',
    'session_protocol' => '',
    'session_host' => '',
    'session_port' => 0,
    'session_path' => '',
    'session_ingress_class_name' => '',
    'session_ingress_annotations' => [
        
    ],
    'session_tls_secret_name' => '',
    'session_storage_class' => '',
    'service_account_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', [
  'body' => '{
  "name": "",
  "config_name": "",
  "session_protocol": "",
  "session_host": "",
  "session_port": 0,
  "session_path": "",
  "session_ingress_class_name": "",
  "session_ingress_annotations": {},
  "session_tls_secret_name": "",
  "session_storage_class": "",
  "service_account_name": ""
}',
  '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' => '',
  'config_name' => '',
  'session_protocol' => '',
  'session_host' => '',
  'session_port' => 0,
  'session_path' => '',
  'session_ingress_class_name' => '',
  'session_ingress_annotations' => [
    
  ],
  'session_tls_secret_name' => '',
  'session_storage_class' => '',
  'service_account_name' => ''
]));

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

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

append(json_encode([
  'name' => '',
  'config_name' => '',
  'session_protocol' => '',
  'session_host' => '',
  'session_port' => 0,
  'session_path' => '',
  'session_ingress_class_name' => '',
  'session_ingress_annotations' => [
    
  ],
  'session_tls_secret_name' => '',
  'session_storage_class' => '',
  'service_account_name' => ''
]));
$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": "",
  "config_name": "",
  "session_protocol": "",
  "session_host": "",
  "session_port": 0,
  "session_path": "",
  "session_ingress_class_name": "",
  "session_ingress_annotations": {},
  "session_tls_secret_name": "",
  "session_storage_class": "",
  "service_account_name": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/clusters' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "config_name": "",
  "session_protocol": "",
  "session_host": "",
  "session_port": 0,
  "session_path": "",
  "session_ingress_class_name": "",
  "session_ingress_annotations": {},
  "session_tls_secret_name": "",
  "session_storage_class": "",
  "service_account_name": ""
}'

import http.client

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

payload = "{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\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": "",
    "config_name": "",
    "session_protocol": "",
    "session_host": "",
    "session_port": 0,
    "session_path": "",
    "session_ingress_class_name": "",
    "session_ingress_annotations": {},
    "session_tls_secret_name": "",
    "session_storage_class": "",
    "service_account_name": ""
}
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  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/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  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/clusters') do |req|
  req.body = "{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\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": "",
        "config_name": "",
        "session_protocol": "",
        "session_host": "",
        "session_port": 0,
        "session_path": "",
        "session_ingress_class_name": "",
        "session_ingress_annotations": json!({}),
        "session_tls_secret_name": "",
        "session_storage_class": "",
        "service_account_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 '{
  "name": "",
  "config_name": "",
  "session_protocol": "",
  "session_host": "",
  "session_port": 0,
  "session_path": "",
  "session_ingress_class_name": "",
  "session_ingress_annotations": {},
  "session_tls_secret_name": "",
  "session_storage_class": "",
  "service_account_name": ""
}' |  \
  http POST {{baseUrl}}/clusters \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "config_name": "",\n  "session_protocol": "",\n  "session_host": "",\n  "session_port": 0,\n  "session_path": "",\n  "session_ingress_class_name": "",\n  "session_ingress_annotations": {},\n  "session_tls_secret_name": "",\n  "session_storage_class": "",\n  "service_account_name": ""\n}' \
  --output-document \
  - {{baseUrl}}/clusters

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "name": "",
  "config_name": "",
  "session_protocol": "",
  "session_host": "",
  "session_port": 0,
  "session_path": "",
  "session_ingress_class_name": "",
  "session_ingress_annotations": [],
  "session_tls_secret_name": "",
  "session_storage_class": "",
  "service_account_name": ""
] 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, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/clusters/:cluster_id");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/clusters/:cluster_id")

require "http/client"

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

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/clusters/:cluster_id'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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/:cluster_id');

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

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

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

const options = {method: 'GET', url: '{{baseUrl}}/clusters/:cluster_id'};

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/clusters/:cluster_id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/clusters/:cluster_id' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/clusters/:cluster_id")

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

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

import requests

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

response = requests.get(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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/:cluster_id') do |req|
end

puts response.status
puts response.body

use reqwest;

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

    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/:cluster_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/clusters/:cluster_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clusters/:cluster_id")! 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, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/clusters/:cluster_id");

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

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

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

package main

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

func main() {

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

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

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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/:cluster_id');

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

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

response = requests.delete(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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/:cluster_id') 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/:cluster_id";

    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/:cluster_id

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

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/clusters/:cluster_id")! 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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/clusters/:cluster_id");

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  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/clusters/:cluster_id" {:content-type :json
                                                                :form-params {:name ""
                                                                              :config_name ""
                                                                              :session_protocol ""
                                                                              :session_host ""
                                                                              :session_port 0
                                                                              :session_path ""
                                                                              :session_ingress_class_name ""
                                                                              :session_ingress_annotations {}
                                                                              :session_tls_secret_name ""
                                                                              :session_storage_class ""
                                                                              :service_account_name ""}})

require "http/client"

url = "{{baseUrl}}/clusters/:cluster_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/clusters/:cluster_id"),
    Content = new StringContent("{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/clusters/:cluster_id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}")

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

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

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

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

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

}

PUT /baseUrl/clusters/:cluster_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 295

{
  "name": "",
  "config_name": "",
  "session_protocol": "",
  "session_host": "",
  "session_port": 0,
  "session_path": "",
  "session_ingress_class_name": "",
  "session_ingress_annotations": {},
  "session_tls_secret_name": "",
  "session_storage_class": "",
  "service_account_name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/clusters/:cluster_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clusters/:cluster_id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/clusters/:cluster_id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/clusters/:cluster_id")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  config_name: '',
  session_protocol: '',
  session_host: '',
  session_port: 0,
  session_path: '',
  session_ingress_class_name: '',
  session_ingress_annotations: {},
  session_tls_secret_name: '',
  session_storage_class: '',
  service_account_name: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/clusters/:cluster_id',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    config_name: '',
    session_protocol: '',
    session_host: '',
    session_port: 0,
    session_path: '',
    session_ingress_class_name: '',
    session_ingress_annotations: {},
    session_tls_secret_name: '',
    session_storage_class: '',
    service_account_name: ''
  }
};

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

const url = '{{baseUrl}}/clusters/:cluster_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","config_name":"","session_protocol":"","session_host":"","session_port":0,"session_path":"","session_ingress_class_name":"","session_ingress_annotations":{},"session_tls_secret_name":"","session_storage_class":"","service_account_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/:cluster_id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "config_name": "",\n  "session_protocol": "",\n  "session_host": "",\n  "session_port": 0,\n  "session_path": "",\n  "session_ingress_class_name": "",\n  "session_ingress_annotations": {},\n  "session_tls_secret_name": "",\n  "session_storage_class": "",\n  "service_account_name": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/clusters/:cluster_id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/clusters/:cluster_id',
  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: '',
  config_name: '',
  session_protocol: '',
  session_host: '',
  session_port: 0,
  session_path: '',
  session_ingress_class_name: '',
  session_ingress_annotations: {},
  session_tls_secret_name: '',
  session_storage_class: '',
  service_account_name: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/clusters/:cluster_id',
  headers: {'content-type': 'application/json'},
  body: {
    name: '',
    config_name: '',
    session_protocol: '',
    session_host: '',
    session_port: 0,
    session_path: '',
    session_ingress_class_name: '',
    session_ingress_annotations: {},
    session_tls_secret_name: '',
    session_storage_class: '',
    service_account_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('PUT', '{{baseUrl}}/clusters/:cluster_id');

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

req.type('json');
req.send({
  name: '',
  config_name: '',
  session_protocol: '',
  session_host: '',
  session_port: 0,
  session_path: '',
  session_ingress_class_name: '',
  session_ingress_annotations: {},
  session_tls_secret_name: '',
  session_storage_class: '',
  service_account_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: 'PUT',
  url: '{{baseUrl}}/clusters/:cluster_id',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    config_name: '',
    session_protocol: '',
    session_host: '',
    session_port: 0,
    session_path: '',
    session_ingress_class_name: '',
    session_ingress_annotations: {},
    session_tls_secret_name: '',
    session_storage_class: '',
    service_account_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/:cluster_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","config_name":"","session_protocol":"","session_host":"","session_port":0,"session_path":"","session_ingress_class_name":"","session_ingress_annotations":{},"session_tls_secret_name":"","session_storage_class":"","service_account_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 = @{ @"name": @"",
                              @"config_name": @"",
                              @"session_protocol": @"",
                              @"session_host": @"",
                              @"session_port": @0,
                              @"session_path": @"",
                              @"session_ingress_class_name": @"",
                              @"session_ingress_annotations": @{  },
                              @"session_tls_secret_name": @"",
                              @"session_storage_class": @"",
                              @"service_account_name": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/clusters/:cluster_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}" in

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

 "{{baseUrl}}/clusters/:cluster_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => '',
    'config_name' => '',
    'session_protocol' => '',
    'session_host' => '',
    'session_port' => 0,
    'session_path' => '',
    'session_ingress_class_name' => '',
    'session_ingress_annotations' => [
        
    ],
    'session_tls_secret_name' => '',
    'session_storage_class' => '',
    'service_account_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('PUT', '{{baseUrl}}/clusters/:cluster_id', [
  'body' => '{
  "name": "",
  "config_name": "",
  "session_protocol": "",
  "session_host": "",
  "session_port": 0,
  "session_path": "",
  "session_ingress_class_name": "",
  "session_ingress_annotations": {},
  "session_tls_secret_name": "",
  "session_storage_class": "",
  "service_account_name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'config_name' => '',
  'session_protocol' => '',
  'session_host' => '',
  'session_port' => 0,
  'session_path' => '',
  'session_ingress_class_name' => '',
  'session_ingress_annotations' => [
    
  ],
  'session_tls_secret_name' => '',
  'session_storage_class' => '',
  'service_account_name' => ''
]));

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

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

append(json_encode([
  'name' => '',
  'config_name' => '',
  'session_protocol' => '',
  'session_host' => '',
  'session_port' => 0,
  'session_path' => '',
  'session_ingress_class_name' => '',
  'session_ingress_annotations' => [
    
  ],
  'session_tls_secret_name' => '',
  'session_storage_class' => '',
  'service_account_name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/clusters/:cluster_id');
$request->setRequestMethod('PUT');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/clusters/:cluster_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "config_name": "",
  "session_protocol": "",
  "session_host": "",
  "session_port": 0,
  "session_path": "",
  "session_ingress_class_name": "",
  "session_ingress_annotations": {},
  "session_tls_secret_name": "",
  "session_storage_class": "",
  "service_account_name": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/clusters/:cluster_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "config_name": "",
  "session_protocol": "",
  "session_host": "",
  "session_port": 0,
  "session_path": "",
  "session_ingress_class_name": "",
  "session_ingress_annotations": {},
  "session_tls_secret_name": "",
  "session_storage_class": "",
  "service_account_name": ""
}'

import http.client

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

payload = "{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}"

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

conn.request("PUT", "/baseUrl/clusters/:cluster_id", payload, headers)

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

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

import requests

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

payload = {
    "name": "",
    "config_name": "",
    "session_protocol": "",
    "session_host": "",
    "session_port": 0,
    "session_path": "",
    "session_ingress_class_name": "",
    "session_ingress_annotations": {},
    "session_tls_secret_name": "",
    "session_storage_class": "",
    "service_account_name": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}"

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

require 'faraday'

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

response = conn.put('/baseUrl/clusters/:cluster_id') do |req|
  req.body = "{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}"
end

puts response.status
puts response.body

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

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

    let payload = json!({
        "name": "",
        "config_name": "",
        "session_protocol": "",
        "session_host": "",
        "session_port": 0,
        "session_path": "",
        "session_ingress_class_name": "",
        "session_ingress_annotations": json!({}),
        "session_tls_secret_name": "",
        "session_storage_class": "",
        "service_account_name": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "name": "",
  "config_name": "",
  "session_protocol": "",
  "session_host": "",
  "session_port": 0,
  "session_path": "",
  "session_ingress_class_name": "",
  "session_ingress_annotations": {},
  "session_tls_secret_name": "",
  "session_storage_class": "",
  "service_account_name": ""
}' |  \
  http PUT {{baseUrl}}/clusters/:cluster_id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "config_name": "",\n  "session_protocol": "",\n  "session_host": "",\n  "session_port": 0,\n  "session_path": "",\n  "session_ingress_class_name": "",\n  "session_ingress_annotations": {},\n  "session_tls_secret_name": "",\n  "session_storage_class": "",\n  "service_account_name": ""\n}' \
  --output-document \
  - {{baseUrl}}/clusters/:cluster_id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "name": "",
  "config_name": "",
  "session_protocol": "",
  "session_host": "",
  "session_port": 0,
  "session_path": "",
  "session_ingress_class_name": "",
  "session_ingress_annotations": [],
  "session_tls_secret_name": "",
  "session_storage_class": "",
  "service_account_name": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/clusters/:cluster_id");

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  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/clusters/:cluster_id" {:content-type :json
                                                                  :form-params {:name ""
                                                                                :config_name ""
                                                                                :session_protocol ""
                                                                                :session_host ""
                                                                                :session_port 0
                                                                                :session_path ""
                                                                                :session_ingress_class_name ""
                                                                                :session_ingress_annotations {}
                                                                                :session_tls_secret_name ""
                                                                                :session_storage_class ""
                                                                                :service_account_name ""}})

require "http/client"

url = "{{baseUrl}}/clusters/:cluster_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/clusters/:cluster_id"),
    Content = new StringContent("{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/clusters/:cluster_id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

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

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}")

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

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

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

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

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

}

PATCH /baseUrl/clusters/:cluster_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 295

{
  "name": "",
  "config_name": "",
  "session_protocol": "",
  "session_host": "",
  "session_port": 0,
  "session_path": "",
  "session_ingress_class_name": "",
  "session_ingress_annotations": {},
  "session_tls_secret_name": "",
  "session_storage_class": "",
  "service_account_name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/clusters/:cluster_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/clusters/:cluster_id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/clusters/:cluster_id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/clusters/:cluster_id")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  config_name: '',
  session_protocol: '',
  session_host: '',
  session_port: 0,
  session_path: '',
  session_ingress_class_name: '',
  session_ingress_annotations: {},
  session_tls_secret_name: '',
  session_storage_class: '',
  service_account_name: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/clusters/:cluster_id',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    config_name: '',
    session_protocol: '',
    session_host: '',
    session_port: 0,
    session_path: '',
    session_ingress_class_name: '',
    session_ingress_annotations: {},
    session_tls_secret_name: '',
    session_storage_class: '',
    service_account_name: ''
  }
};

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

const url = '{{baseUrl}}/clusters/:cluster_id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","config_name":"","session_protocol":"","session_host":"","session_port":0,"session_path":"","session_ingress_class_name":"","session_ingress_annotations":{},"session_tls_secret_name":"","session_storage_class":"","service_account_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/:cluster_id',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "config_name": "",\n  "session_protocol": "",\n  "session_host": "",\n  "session_port": 0,\n  "session_path": "",\n  "session_ingress_class_name": "",\n  "session_ingress_annotations": {},\n  "session_tls_secret_name": "",\n  "session_storage_class": "",\n  "service_account_name": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/clusters/:cluster_id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/clusters/:cluster_id',
  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: '',
  config_name: '',
  session_protocol: '',
  session_host: '',
  session_port: 0,
  session_path: '',
  session_ingress_class_name: '',
  session_ingress_annotations: {},
  session_tls_secret_name: '',
  session_storage_class: '',
  service_account_name: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/clusters/:cluster_id',
  headers: {'content-type': 'application/json'},
  body: {
    name: '',
    config_name: '',
    session_protocol: '',
    session_host: '',
    session_port: 0,
    session_path: '',
    session_ingress_class_name: '',
    session_ingress_annotations: {},
    session_tls_secret_name: '',
    session_storage_class: '',
    service_account_name: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/clusters/:cluster_id');

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

req.type('json');
req.send({
  name: '',
  config_name: '',
  session_protocol: '',
  session_host: '',
  session_port: 0,
  session_path: '',
  session_ingress_class_name: '',
  session_ingress_annotations: {},
  session_tls_secret_name: '',
  session_storage_class: '',
  service_account_name: ''
});

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/clusters/:cluster_id',
  headers: {'content-type': 'application/json'},
  data: {
    name: '',
    config_name: '',
    session_protocol: '',
    session_host: '',
    session_port: 0,
    session_path: '',
    session_ingress_class_name: '',
    session_ingress_annotations: {},
    session_tls_secret_name: '',
    session_storage_class: '',
    service_account_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/:cluster_id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"name":"","config_name":"","session_protocol":"","session_host":"","session_port":0,"session_path":"","session_ingress_class_name":"","session_ingress_annotations":{},"session_tls_secret_name":"","session_storage_class":"","service_account_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 = @{ @"name": @"",
                              @"config_name": @"",
                              @"session_protocol": @"",
                              @"session_host": @"",
                              @"session_port": @0,
                              @"session_path": @"",
                              @"session_ingress_class_name": @"",
                              @"session_ingress_annotations": @{  },
                              @"session_tls_secret_name": @"",
                              @"session_storage_class": @"",
                              @"service_account_name": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/clusters/:cluster_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}" in

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

 "{{baseUrl}}/clusters/:cluster_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => '',
    'config_name' => '',
    'session_protocol' => '',
    'session_host' => '',
    'session_port' => 0,
    'session_path' => '',
    'session_ingress_class_name' => '',
    'session_ingress_annotations' => [
        
    ],
    'session_tls_secret_name' => '',
    'session_storage_class' => '',
    'service_account_name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PATCH', '{{baseUrl}}/clusters/:cluster_id', [
  'body' => '{
  "name": "",
  "config_name": "",
  "session_protocol": "",
  "session_host": "",
  "session_port": 0,
  "session_path": "",
  "session_ingress_class_name": "",
  "session_ingress_annotations": {},
  "session_tls_secret_name": "",
  "session_storage_class": "",
  "service_account_name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'config_name' => '',
  'session_protocol' => '',
  'session_host' => '',
  'session_port' => 0,
  'session_path' => '',
  'session_ingress_class_name' => '',
  'session_ingress_annotations' => [
    
  ],
  'session_tls_secret_name' => '',
  'session_storage_class' => '',
  'service_account_name' => ''
]));

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

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

append(json_encode([
  'name' => '',
  'config_name' => '',
  'session_protocol' => '',
  'session_host' => '',
  'session_port' => 0,
  'session_path' => '',
  'session_ingress_class_name' => '',
  'session_ingress_annotations' => [
    
  ],
  'session_tls_secret_name' => '',
  'session_storage_class' => '',
  'service_account_name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/clusters/:cluster_id');
$request->setRequestMethod('PATCH');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/clusters/:cluster_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "config_name": "",
  "session_protocol": "",
  "session_host": "",
  "session_port": 0,
  "session_path": "",
  "session_ingress_class_name": "",
  "session_ingress_annotations": {},
  "session_tls_secret_name": "",
  "session_storage_class": "",
  "service_account_name": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/clusters/:cluster_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "config_name": "",
  "session_protocol": "",
  "session_host": "",
  "session_port": 0,
  "session_path": "",
  "session_ingress_class_name": "",
  "session_ingress_annotations": {},
  "session_tls_secret_name": "",
  "session_storage_class": "",
  "service_account_name": ""
}'

import http.client

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

payload = "{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}"

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

conn.request("PATCH", "/baseUrl/clusters/:cluster_id", payload, headers)

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

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

import requests

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

payload = {
    "name": "",
    "config_name": "",
    "session_protocol": "",
    "session_host": "",
    "session_port": 0,
    "session_path": "",
    "session_ingress_class_name": "",
    "session_ingress_annotations": {},
    "session_tls_secret_name": "",
    "session_storage_class": "",
    "service_account_name": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

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

payload <- "{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}"

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

require 'faraday'

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

response = conn.patch('/baseUrl/clusters/:cluster_id') do |req|
  req.body = "{\n  \"name\": \"\",\n  \"config_name\": \"\",\n  \"session_protocol\": \"\",\n  \"session_host\": \"\",\n  \"session_port\": 0,\n  \"session_path\": \"\",\n  \"session_ingress_class_name\": \"\",\n  \"session_ingress_annotations\": {},\n  \"session_tls_secret_name\": \"\",\n  \"session_storage_class\": \"\",\n  \"service_account_name\": \"\"\n}"
end

puts response.status
puts response.body

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

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

    let payload = json!({
        "name": "",
        "config_name": "",
        "session_protocol": "",
        "session_host": "",
        "session_port": 0,
        "session_path": "",
        "session_ingress_class_name": "",
        "session_ingress_annotations": json!({}),
        "session_tls_secret_name": "",
        "session_storage_class": "",
        "service_account_name": ""
    });

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

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

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

    dbg!(results);
}

echo '{
  "name": "",
  "config_name": "",
  "session_protocol": "",
  "session_host": "",
  "session_port": 0,
  "session_path": "",
  "session_ingress_class_name": "",
  "session_ingress_annotations": {},
  "session_tls_secret_name": "",
  "session_storage_class": "",
  "service_account_name": ""
}' |  \
  http PATCH {{baseUrl}}/clusters/:cluster_id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "config_name": "",\n  "session_protocol": "",\n  "session_host": "",\n  "session_port": 0,\n  "session_path": "",\n  "session_ingress_class_name": "",\n  "session_ingress_annotations": {},\n  "session_tls_secret_name": "",\n  "session_storage_class": "",\n  "service_account_name": ""\n}' \
  --output-document \
  - {{baseUrl}}/clusters/:cluster_id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "name": "",
  "config_name": "",
  "session_protocol": "",
  "session_host": "",
  "session_port": 0,
  "session_path": "",
  "session_ingress_class_name": "",
  "session_ingress_annotations": [],
  "session_tls_secret_name": "",
  "session_storage_class": "",
  "service_account_name": ""
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resource_pools/:resource_pool_id/quota");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/resource_pools/:resource_pool_id/quota")

require "http/client"

url = "{{baseUrl}}/resource_pools/:resource_pool_id/quota"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/resource_pools/:resource_pool_id/quota"

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

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

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

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

}

GET /baseUrl/resource_pools/:resource_pool_id/quota HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/quota")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/resource_pools/:resource_pool_id/quota")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/resource_pools/:resource_pool_id/quota');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/quota'
};

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

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/quota';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/quota',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/quota")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource_pools/:resource_pool_id/quota',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/quota'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/resource_pools/:resource_pool_id/quota');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/quota'
};

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

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

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/quota';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resource_pools/:resource_pool_id/quota"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resource_pools/:resource_pool_id/quota" in

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

 "{{baseUrl}}/resource_pools/:resource_pool_id/quota",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/resource_pools/:resource_pool_id/quota');

echo $response->getBody();

setUrl('{{baseUrl}}/resource_pools/:resource_pool_id/quota');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/quota' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/quota' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/resource_pools/:resource_pool_id/quota")

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

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

import requests

url = "{{baseUrl}}/resource_pools/:resource_pool_id/quota"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource_pools/:resource_pool_id/quota"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource_pools/:resource_pool_id/quota")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/resource_pools/:resource_pool_id/quota') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/resource_pools/:resource_pool_id/quota

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/resource_pools/:resource_pool_id/quota

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resource_pools/:resource_pool_id/quota");

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  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/patch "{{baseUrl}}/resource_pools/:resource_pool_id/quota" {:content-type :json
                                                                                    :form-params {:cpu ""
                                                                                                  :memory 0
                                                                                                  :gpu 0}})

require "http/client"

url = "{{baseUrl}}/resource_pools/:resource_pool_id/quota"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/resource_pools/:resource_pool_id/quota"),
    Content = new StringContent("{\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0\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}}/resource_pools/:resource_pool_id/quota");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/resource_pools/:resource_pool_id/quota"

	payload := strings.NewReader("{\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0\n}")

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

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

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

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

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

}

PATCH /baseUrl/resource_pools/:resource_pool_id/quota HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 42

{
  "cpu": "",
  "memory": 0,
  "gpu": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/resource_pools/:resource_pool_id/quota")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resource_pools/:resource_pool_id/quota"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0\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  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/quota")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.patch("{{baseUrl}}/resource_pools/:resource_pool_id/quota")
  .header("content-type", "application/json")
  .body("{\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0\n}")
  .asString();

const data = JSON.stringify({
  cpu: '',
  memory: 0,
  gpu: 0
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/quota',
  headers: {'content-type': 'application/json'},
  data: {cpu: '', memory: 0, gpu: 0}
};

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

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/quota';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"cpu":"","memory":0,"gpu":0}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/quota',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cpu": "",\n  "memory": 0,\n  "gpu": 0\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/quota")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource_pools/:resource_pool_id/quota',
  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({cpu: '', memory: 0, gpu: 0}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/quota',
  headers: {'content-type': 'application/json'},
  body: {cpu: '', memory: 0, gpu: 0},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/resource_pools/:resource_pool_id/quota');

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

req.type('json');
req.send({
  cpu: '',
  memory: 0,
  gpu: 0
});

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

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

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

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/quota',
  headers: {'content-type': 'application/json'},
  data: {cpu: '', memory: 0, gpu: 0}
};

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

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

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/quota';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"cpu":"","memory":0,"gpu":0}'
};

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 = @{ @"cpu": @"",
                              @"memory": @0,
                              @"gpu": @0 };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resource_pools/:resource_pool_id/quota"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resource_pools/:resource_pool_id/quota" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0\n}" in

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

 "{{baseUrl}}/resource_pools/:resource_pool_id/quota",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'cpu' => '',
    'memory' => 0,
    'gpu' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PATCH', '{{baseUrl}}/resource_pools/:resource_pool_id/quota', [
  'body' => '{
  "cpu": "",
  "memory": 0,
  "gpu": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resource_pools/:resource_pool_id/quota');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cpu' => '',
  'memory' => 0,
  'gpu' => 0
]));

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

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

append(json_encode([
  'cpu' => '',
  'memory' => 0,
  'gpu' => 0
]));
$request->setRequestUrl('{{baseUrl}}/resource_pools/:resource_pool_id/quota');
$request->setRequestMethod('PATCH');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/quota' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "cpu": "",
  "memory": 0,
  "gpu": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/quota' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "cpu": "",
  "memory": 0,
  "gpu": 0
}'

import http.client

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

payload = "{\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0\n}"

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

conn.request("PATCH", "/baseUrl/resource_pools/:resource_pool_id/quota", payload, headers)

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

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

import requests

url = "{{baseUrl}}/resource_pools/:resource_pool_id/quota"

payload = {
    "cpu": "",
    "memory": 0,
    "gpu": 0
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource_pools/:resource_pool_id/quota"

payload <- "{\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource_pools/:resource_pool_id/quota")

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

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0\n}"

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

require 'faraday'

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

response = conn.patch('/baseUrl/resource_pools/:resource_pool_id/quota') do |req|
  req.body = "{\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0\n}"
end

puts response.status
puts response.body

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

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

    let payload = json!({
        "cpu": "",
        "memory": 0,
        "gpu": 0
    });

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

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

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

    dbg!(results);
}

echo '{
  "cpu": "",
  "memory": 0,
  "gpu": 0
}' |  \
  http PATCH {{baseUrl}}/resource_pools/:resource_pool_id/quota \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "cpu": "",\n  "memory": 0,\n  "gpu": 0\n}' \
  --output-document \
  - {{baseUrl}}/resource_pools/:resource_pool_id/quota

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "cpu": "",
  "memory": 0,
  "gpu": 0
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resource_pools/:resource_pool_id/quota");

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  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/resource_pools/:resource_pool_id/quota" {:content-type :json
                                                                                  :form-params {:cpu ""
                                                                                                :memory 0
                                                                                                :gpu 0
                                                                                                :id ""}})

require "http/client"

url = "{{baseUrl}}/resource_pools/:resource_pool_id/quota"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"id\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/resource_pools/:resource_pool_id/quota"),
    Content = new StringContent("{\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"id\": \"\"\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}}/resource_pools/:resource_pool_id/quota");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/resource_pools/:resource_pool_id/quota"

	payload := strings.NewReader("{\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"id\": \"\"\n}")

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

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

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

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

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

}

PUT /baseUrl/resource_pools/:resource_pool_id/quota HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 54

{
  "cpu": "",
  "memory": 0,
  "gpu": 0,
  "id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/resource_pools/:resource_pool_id/quota")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resource_pools/:resource_pool_id/quota"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"id\": \"\"\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  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/quota")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/resource_pools/:resource_pool_id/quota")
  .header("content-type", "application/json")
  .body("{\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  cpu: '',
  memory: 0,
  gpu: 0,
  id: ''
});

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

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

xhr.open('PUT', '{{baseUrl}}/resource_pools/:resource_pool_id/quota');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/quota',
  headers: {'content-type': 'application/json'},
  data: {cpu: '', memory: 0, gpu: 0, id: ''}
};

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

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/quota';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"cpu":"","memory":0,"gpu":0,"id":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/quota',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "cpu": "",\n  "memory": 0,\n  "gpu": 0,\n  "id": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/quota")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource_pools/:resource_pool_id/quota',
  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({cpu: '', memory: 0, gpu: 0, id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/quota',
  headers: {'content-type': 'application/json'},
  body: {cpu: '', memory: 0, gpu: 0, id: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/resource_pools/:resource_pool_id/quota');

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

req.type('json');
req.send({
  cpu: '',
  memory: 0,
  gpu: 0,
  id: ''
});

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/quota',
  headers: {'content-type': 'application/json'},
  data: {cpu: '', memory: 0, gpu: 0, id: ''}
};

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

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

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/quota';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"cpu":"","memory":0,"gpu":0,"id":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"cpu": @"",
                              @"memory": @0,
                              @"gpu": @0,
                              @"id": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resource_pools/:resource_pool_id/quota" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"id\": \"\"\n}" in

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

 "{{baseUrl}}/resource_pools/:resource_pool_id/quota",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'cpu' => '',
    'memory' => 0,
    'gpu' => 0,
    'id' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/resource_pools/:resource_pool_id/quota', [
  'body' => '{
  "cpu": "",
  "memory": 0,
  "gpu": 0,
  "id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resource_pools/:resource_pool_id/quota');
$request->setMethod(HTTP_METH_PUT);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'cpu' => '',
  'memory' => 0,
  'gpu' => 0,
  'id' => ''
]));

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

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

append(json_encode([
  'cpu' => '',
  'memory' => 0,
  'gpu' => 0,
  'id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/resource_pools/:resource_pool_id/quota');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/quota' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "cpu": "",
  "memory": 0,
  "gpu": 0,
  "id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/quota' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "cpu": "",
  "memory": 0,
  "gpu": 0,
  "id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"id\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/resource_pools/:resource_pool_id/quota", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resource_pools/:resource_pool_id/quota"

payload = {
    "cpu": "",
    "memory": 0,
    "gpu": 0,
    "id": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource_pools/:resource_pool_id/quota"

payload <- "{\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"id\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource_pools/:resource_pool_id/quota")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"id\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/resource_pools/:resource_pool_id/quota') do |req|
  req.body = "{\n  \"cpu\": \"\",\n  \"memory\": 0,\n  \"gpu\": 0,\n  \"id\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resource_pools/:resource_pool_id/quota";

    let payload = json!({
        "cpu": "",
        "memory": 0,
        "gpu": 0,
        "id": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "cpu": "",
  "memory": 0,
  "gpu": 0,
  "id": ""
}' |  \
  http PUT {{baseUrl}}/resource_pools/:resource_pool_id/quota \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "cpu": "",\n  "memory": 0,\n  "gpu": 0,\n  "id": ""\n}' \
  --output-document \
  - {{baseUrl}}/resource_pools/:resource_pool_id/quota

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "cpu": "",
  "memory": 0,
  "gpu": 0,
  "id": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resource_pools/:resource_pool_id/quota")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resource_pools/:resource_pool_id/users");

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  {\n    \"id\": \"\",\n    \"no_default_access\": false\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/resource_pools/:resource_pool_id/users" {:content-type :json
                                                                                   :form-params [{:id ""
                                                                                                  :no_default_access false}]})

require "http/client"

url = "{{baseUrl}}/resource_pools/:resource_pool_id/users"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"id\": \"\",\n    \"no_default_access\": false\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}}/resource_pools/:resource_pool_id/users"),
    Content = new StringContent("[\n  {\n    \"id\": \"\",\n    \"no_default_access\": false\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}}/resource_pools/:resource_pool_id/users");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"id\": \"\",\n    \"no_default_access\": false\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resource_pools/:resource_pool_id/users"

	payload := strings.NewReader("[\n  {\n    \"id\": \"\",\n    \"no_default_access\": false\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/resource_pools/:resource_pool_id/users HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 56

[
  {
    "id": "",
    "no_default_access": false
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/resource_pools/:resource_pool_id/users")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"id\": \"\",\n    \"no_default_access\": false\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resource_pools/:resource_pool_id/users"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"id\": \"\",\n    \"no_default_access\": false\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  {\n    \"id\": \"\",\n    \"no_default_access\": false\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/users")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/resource_pools/:resource_pool_id/users")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"id\": \"\",\n    \"no_default_access\": false\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    id: '',
    no_default_access: false
  }
]);

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/resource_pools/:resource_pool_id/users');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/users',
  headers: {'content-type': 'application/json'},
  data: [{id: '', no_default_access: false}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/users';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","no_default_access":false}]'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/users',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "id": "",\n    "no_default_access": false\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  {\n    \"id\": \"\",\n    \"no_default_access\": false\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/users")
  .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/resource_pools/:resource_pool_id/users',
  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([{id: '', no_default_access: false}]));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/users',
  headers: {'content-type': 'application/json'},
  body: [{id: '', no_default_access: false}],
  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}}/resource_pools/:resource_pool_id/users');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {
    id: '',
    no_default_access: false
  }
]);

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}}/resource_pools/:resource_pool_id/users',
  headers: {'content-type': 'application/json'},
  data: [{id: '', no_default_access: false}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/users';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","no_default_access":false}]'
};

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 = @[ @{ @"id": @"", @"no_default_access": @NO } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resource_pools/:resource_pool_id/users"]
                                                       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}}/resource_pools/:resource_pool_id/users" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"id\": \"\",\n    \"no_default_access\": false\n  }\n]" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resource_pools/:resource_pool_id/users",
  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([
    [
        'id' => '',
        'no_default_access' => null
    ]
  ]),
  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}}/resource_pools/:resource_pool_id/users', [
  'body' => '[
  {
    "id": "",
    "no_default_access": false
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resource_pools/:resource_pool_id/users');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'id' => '',
    'no_default_access' => null
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    'id' => '',
    'no_default_access' => null
  ]
]));
$request->setRequestUrl('{{baseUrl}}/resource_pools/:resource_pool_id/users');
$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}}/resource_pools/:resource_pool_id/users' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": "",
    "no_default_access": false
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/users' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": "",
    "no_default_access": false
  }
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {\n    \"id\": \"\",\n    \"no_default_access\": false\n  }\n]"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/resource_pools/:resource_pool_id/users", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resource_pools/:resource_pool_id/users"

payload = [
    {
        "id": "",
        "no_default_access": False
    }
]
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource_pools/:resource_pool_id/users"

payload <- "[\n  {\n    \"id\": \"\",\n    \"no_default_access\": false\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}}/resource_pools/:resource_pool_id/users")

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  {\n    \"id\": \"\",\n    \"no_default_access\": false\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/resource_pools/:resource_pool_id/users') do |req|
  req.body = "[\n  {\n    \"id\": \"\",\n    \"no_default_access\": false\n  }\n]"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resource_pools/:resource_pool_id/users";

    let payload = (
        json!({
            "id": "",
            "no_default_access": false
        })
    );

    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 '[
  {
    "id": "",
    "no_default_access": false
  }
]' |  \
  http POST {{baseUrl}}/resource_pools/:resource_pool_id/users \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "id": "",\n    "no_default_access": false\n  }\n]' \
  --output-document \
  - {{baseUrl}}/resource_pools/:resource_pool_id/users

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "id": "",
    "no_default_access": false
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resource_pools/:resource_pool_id/users")! 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}}/resource_pools/:resource_pool_id/users/:user_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id")

require "http/client"

url = "{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/resource_pools/:resource_pool_id/users/:user_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource_pools/:resource_pool_id/users/:user_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id');

echo $response->getBody();

setUrl('{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/resource_pools/:resource_pool_id/users/:user_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/resource_pools/:resource_pool_id/users/:user_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id")! 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}}/resource_pools");

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  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/resource_pools" {:content-type :json
                                                           :form-params {:quota {:cpu ""
                                                                                 :memory 0
                                                                                 :gpu 0
                                                                                 :id ""}
                                                                         :classes [{:name ""
                                                                                    :cpu ""
                                                                                    :memory 0
                                                                                    :gpu 0
                                                                                    :max_storage 0
                                                                                    :default_storage 0
                                                                                    :default false
                                                                                    :tolerations []
                                                                                    :node_affinities [{:key ""
                                                                                                       :required_during_scheduling false}]}]
                                                                         :name ""
                                                                         :public false
                                                                         :default false
                                                                         :remote {}
                                                                         :idle_threshold 0
                                                                         :hibernation_threshold 0
                                                                         :cluster_id ""}})

require "http/client"

url = "{{baseUrl}}/resource_pools"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\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}}/resource_pools"),
    Content = new StringContent("{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\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}}/resource_pools");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resource_pools"

	payload := strings.NewReader("{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\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/resource_pools HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 546

{
  "quota": {
    "cpu": "",
    "memory": 0,
    "gpu": 0,
    "id": ""
  },
  "classes": [
    {
      "name": "",
      "cpu": "",
      "memory": 0,
      "gpu": 0,
      "max_storage": 0,
      "default_storage": 0,
      "default": false,
      "tolerations": [],
      "node_affinities": [
        {
          "key": "",
          "required_during_scheduling": false
        }
      ]
    }
  ],
  "name": "",
  "public": false,
  "default": false,
  "remote": {},
  "idle_threshold": 0,
  "hibernation_threshold": 0,
  "cluster_id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/resource_pools")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resource_pools"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\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  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/resource_pools")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/resource_pools")
  .header("content-type", "application/json")
  .body("{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  quota: {
    cpu: '',
    memory: 0,
    gpu: 0,
    id: ''
  },
  classes: [
    {
      name: '',
      cpu: '',
      memory: 0,
      gpu: 0,
      max_storage: 0,
      default_storage: 0,
      default: false,
      tolerations: [],
      node_affinities: [
        {
          key: '',
          required_during_scheduling: false
        }
      ]
    }
  ],
  name: '',
  public: false,
  default: false,
  remote: {},
  idle_threshold: 0,
  hibernation_threshold: 0,
  cluster_id: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/resource_pools');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/resource_pools',
  headers: {'content-type': 'application/json'},
  data: {
    quota: {cpu: '', memory: 0, gpu: 0, id: ''},
    classes: [
      {
        name: '',
        cpu: '',
        memory: 0,
        gpu: 0,
        max_storage: 0,
        default_storage: 0,
        default: false,
        tolerations: [],
        node_affinities: [{key: '', required_during_scheduling: false}]
      }
    ],
    name: '',
    public: false,
    default: false,
    remote: {},
    idle_threshold: 0,
    hibernation_threshold: 0,
    cluster_id: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resource_pools';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"quota":{"cpu":"","memory":0,"gpu":0,"id":""},"classes":[{"name":"","cpu":"","memory":0,"gpu":0,"max_storage":0,"default_storage":0,"default":false,"tolerations":[],"node_affinities":[{"key":"","required_during_scheduling":false}]}],"name":"","public":false,"default":false,"remote":{},"idle_threshold":0,"hibernation_threshold":0,"cluster_id":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resource_pools',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "quota": {\n    "cpu": "",\n    "memory": 0,\n    "gpu": 0,\n    "id": ""\n  },\n  "classes": [\n    {\n      "name": "",\n      "cpu": "",\n      "memory": 0,\n      "gpu": 0,\n      "max_storage": 0,\n      "default_storage": 0,\n      "default": false,\n      "tolerations": [],\n      "node_affinities": [\n        {\n          "key": "",\n          "required_during_scheduling": false\n        }\n      ]\n    }\n  ],\n  "name": "",\n  "public": false,\n  "default": false,\n  "remote": {},\n  "idle_threshold": 0,\n  "hibernation_threshold": 0,\n  "cluster_id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/resource_pools")
  .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/resource_pools',
  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({
  quota: {cpu: '', memory: 0, gpu: 0, id: ''},
  classes: [
    {
      name: '',
      cpu: '',
      memory: 0,
      gpu: 0,
      max_storage: 0,
      default_storage: 0,
      default: false,
      tolerations: [],
      node_affinities: [{key: '', required_during_scheduling: false}]
    }
  ],
  name: '',
  public: false,
  default: false,
  remote: {},
  idle_threshold: 0,
  hibernation_threshold: 0,
  cluster_id: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/resource_pools',
  headers: {'content-type': 'application/json'},
  body: {
    quota: {cpu: '', memory: 0, gpu: 0, id: ''},
    classes: [
      {
        name: '',
        cpu: '',
        memory: 0,
        gpu: 0,
        max_storage: 0,
        default_storage: 0,
        default: false,
        tolerations: [],
        node_affinities: [{key: '', required_during_scheduling: false}]
      }
    ],
    name: '',
    public: false,
    default: false,
    remote: {},
    idle_threshold: 0,
    hibernation_threshold: 0,
    cluster_id: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/resource_pools');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  quota: {
    cpu: '',
    memory: 0,
    gpu: 0,
    id: ''
  },
  classes: [
    {
      name: '',
      cpu: '',
      memory: 0,
      gpu: 0,
      max_storage: 0,
      default_storage: 0,
      default: false,
      tolerations: [],
      node_affinities: [
        {
          key: '',
          required_during_scheduling: false
        }
      ]
    }
  ],
  name: '',
  public: false,
  default: false,
  remote: {},
  idle_threshold: 0,
  hibernation_threshold: 0,
  cluster_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/resource_pools',
  headers: {'content-type': 'application/json'},
  data: {
    quota: {cpu: '', memory: 0, gpu: 0, id: ''},
    classes: [
      {
        name: '',
        cpu: '',
        memory: 0,
        gpu: 0,
        max_storage: 0,
        default_storage: 0,
        default: false,
        tolerations: [],
        node_affinities: [{key: '', required_during_scheduling: false}]
      }
    ],
    name: '',
    public: false,
    default: false,
    remote: {},
    idle_threshold: 0,
    hibernation_threshold: 0,
    cluster_id: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resource_pools';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"quota":{"cpu":"","memory":0,"gpu":0,"id":""},"classes":[{"name":"","cpu":"","memory":0,"gpu":0,"max_storage":0,"default_storage":0,"default":false,"tolerations":[],"node_affinities":[{"key":"","required_during_scheduling":false}]}],"name":"","public":false,"default":false,"remote":{},"idle_threshold":0,"hibernation_threshold":0,"cluster_id":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"quota": @{ @"cpu": @"", @"memory": @0, @"gpu": @0, @"id": @"" },
                              @"classes": @[ @{ @"name": @"", @"cpu": @"", @"memory": @0, @"gpu": @0, @"max_storage": @0, @"default_storage": @0, @"default": @NO, @"tolerations": @[  ], @"node_affinities": @[ @{ @"key": @"", @"required_during_scheduling": @NO } ] } ],
                              @"name": @"",
                              @"public": @NO,
                              @"default": @NO,
                              @"remote": @{  },
                              @"idle_threshold": @0,
                              @"hibernation_threshold": @0,
                              @"cluster_id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resource_pools"]
                                                       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}}/resource_pools" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resource_pools",
  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([
    'quota' => [
        'cpu' => '',
        'memory' => 0,
        'gpu' => 0,
        'id' => ''
    ],
    'classes' => [
        [
                'name' => '',
                'cpu' => '',
                'memory' => 0,
                'gpu' => 0,
                'max_storage' => 0,
                'default_storage' => 0,
                'default' => null,
                'tolerations' => [
                                
                ],
                'node_affinities' => [
                                [
                                                                'key' => '',
                                                                'required_during_scheduling' => null
                                ]
                ]
        ]
    ],
    'name' => '',
    'public' => null,
    'default' => null,
    'remote' => [
        
    ],
    'idle_threshold' => 0,
    'hibernation_threshold' => 0,
    'cluster_id' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/resource_pools', [
  'body' => '{
  "quota": {
    "cpu": "",
    "memory": 0,
    "gpu": 0,
    "id": ""
  },
  "classes": [
    {
      "name": "",
      "cpu": "",
      "memory": 0,
      "gpu": 0,
      "max_storage": 0,
      "default_storage": 0,
      "default": false,
      "tolerations": [],
      "node_affinities": [
        {
          "key": "",
          "required_during_scheduling": false
        }
      ]
    }
  ],
  "name": "",
  "public": false,
  "default": false,
  "remote": {},
  "idle_threshold": 0,
  "hibernation_threshold": 0,
  "cluster_id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resource_pools');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'quota' => [
    'cpu' => '',
    'memory' => 0,
    'gpu' => 0,
    'id' => ''
  ],
  'classes' => [
    [
        'name' => '',
        'cpu' => '',
        'memory' => 0,
        'gpu' => 0,
        'max_storage' => 0,
        'default_storage' => 0,
        'default' => null,
        'tolerations' => [
                
        ],
        'node_affinities' => [
                [
                                'key' => '',
                                'required_during_scheduling' => null
                ]
        ]
    ]
  ],
  'name' => '',
  'public' => null,
  'default' => null,
  'remote' => [
    
  ],
  'idle_threshold' => 0,
  'hibernation_threshold' => 0,
  'cluster_id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'quota' => [
    'cpu' => '',
    'memory' => 0,
    'gpu' => 0,
    'id' => ''
  ],
  'classes' => [
    [
        'name' => '',
        'cpu' => '',
        'memory' => 0,
        'gpu' => 0,
        'max_storage' => 0,
        'default_storage' => 0,
        'default' => null,
        'tolerations' => [
                
        ],
        'node_affinities' => [
                [
                                'key' => '',
                                'required_during_scheduling' => null
                ]
        ]
    ]
  ],
  'name' => '',
  'public' => null,
  'default' => null,
  'remote' => [
    
  ],
  'idle_threshold' => 0,
  'hibernation_threshold' => 0,
  'cluster_id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/resource_pools');
$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}}/resource_pools' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "quota": {
    "cpu": "",
    "memory": 0,
    "gpu": 0,
    "id": ""
  },
  "classes": [
    {
      "name": "",
      "cpu": "",
      "memory": 0,
      "gpu": 0,
      "max_storage": 0,
      "default_storage": 0,
      "default": false,
      "tolerations": [],
      "node_affinities": [
        {
          "key": "",
          "required_during_scheduling": false
        }
      ]
    }
  ],
  "name": "",
  "public": false,
  "default": false,
  "remote": {},
  "idle_threshold": 0,
  "hibernation_threshold": 0,
  "cluster_id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource_pools' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "quota": {
    "cpu": "",
    "memory": 0,
    "gpu": 0,
    "id": ""
  },
  "classes": [
    {
      "name": "",
      "cpu": "",
      "memory": 0,
      "gpu": 0,
      "max_storage": 0,
      "default_storage": 0,
      "default": false,
      "tolerations": [],
      "node_affinities": [
        {
          "key": "",
          "required_during_scheduling": false
        }
      ]
    }
  ],
  "name": "",
  "public": false,
  "default": false,
  "remote": {},
  "idle_threshold": 0,
  "hibernation_threshold": 0,
  "cluster_id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/resource_pools", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resource_pools"

payload = {
    "quota": {
        "cpu": "",
        "memory": 0,
        "gpu": 0,
        "id": ""
    },
    "classes": [
        {
            "name": "",
            "cpu": "",
            "memory": 0,
            "gpu": 0,
            "max_storage": 0,
            "default_storage": 0,
            "default": False,
            "tolerations": [],
            "node_affinities": [
                {
                    "key": "",
                    "required_during_scheduling": False
                }
            ]
        }
    ],
    "name": "",
    "public": False,
    "default": False,
    "remote": {},
    "idle_threshold": 0,
    "hibernation_threshold": 0,
    "cluster_id": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource_pools"

payload <- "{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\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}}/resource_pools")

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  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\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/resource_pools') do |req|
  req.body = "{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resource_pools";

    let payload = json!({
        "quota": json!({
            "cpu": "",
            "memory": 0,
            "gpu": 0,
            "id": ""
        }),
        "classes": (
            json!({
                "name": "",
                "cpu": "",
                "memory": 0,
                "gpu": 0,
                "max_storage": 0,
                "default_storage": 0,
                "default": false,
                "tolerations": (),
                "node_affinities": (
                    json!({
                        "key": "",
                        "required_during_scheduling": false
                    })
                )
            })
        ),
        "name": "",
        "public": false,
        "default": false,
        "remote": json!({}),
        "idle_threshold": 0,
        "hibernation_threshold": 0,
        "cluster_id": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "quota": {
    "cpu": "",
    "memory": 0,
    "gpu": 0,
    "id": ""
  },
  "classes": [
    {
      "name": "",
      "cpu": "",
      "memory": 0,
      "gpu": 0,
      "max_storage": 0,
      "default_storage": 0,
      "default": false,
      "tolerations": [],
      "node_affinities": [
        {
          "key": "",
          "required_during_scheduling": false
        }
      ]
    }
  ],
  "name": "",
  "public": false,
  "default": false,
  "remote": {},
  "idle_threshold": 0,
  "hibernation_threshold": 0,
  "cluster_id": ""
}' |  \
  http POST {{baseUrl}}/resource_pools \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "quota": {\n    "cpu": "",\n    "memory": 0,\n    "gpu": 0,\n    "id": ""\n  },\n  "classes": [\n    {\n      "name": "",\n      "cpu": "",\n      "memory": 0,\n      "gpu": 0,\n      "max_storage": 0,\n      "default_storage": 0,\n      "default": false,\n      "tolerations": [],\n      "node_affinities": [\n        {\n          "key": "",\n          "required_during_scheduling": false\n        }\n      ]\n    }\n  ],\n  "name": "",\n  "public": false,\n  "default": false,\n  "remote": {},\n  "idle_threshold": 0,\n  "hibernation_threshold": 0,\n  "cluster_id": ""\n}' \
  --output-document \
  - {{baseUrl}}/resource_pools

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "quota": [
    "cpu": "",
    "memory": 0,
    "gpu": 0,
    "id": ""
  ],
  "classes": [
    [
      "name": "",
      "cpu": "",
      "memory": 0,
      "gpu": 0,
      "max_storage": 0,
      "default_storage": 0,
      "default": false,
      "tolerations": [],
      "node_affinities": [
        [
          "key": "",
          "required_during_scheduling": false
        ]
      ]
    ]
  ],
  "name": "",
  "public": false,
  "default": false,
  "remote": [],
  "idle_threshold": 0,
  "hibernation_threshold": 0,
  "cluster_id": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resource_pools")! 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}}/resource_pools/:resource_pool_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/resource_pools/:resource_pool_id")

require "http/client"

url = "{{baseUrl}}/resource_pools/:resource_pool_id"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/resource_pools/:resource_pool_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/resource_pools/:resource_pool_id");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resource_pools/:resource_pool_id"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/resource_pools/:resource_pool_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/resource_pools/:resource_pool_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resource_pools/:resource_pool_id"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/resource_pools/:resource_pool_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/resource_pools/:resource_pool_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resource_pools/:resource_pool_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resource_pools/:resource_pool_id',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource_pools/:resource_pool_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/resource_pools/:resource_pool_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resource_pools/:resource_pool_id';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resource_pools/:resource_pool_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resource_pools/:resource_pool_id" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resource_pools/:resource_pool_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/resource_pools/:resource_pool_id');

echo $response->getBody();

setUrl('{{baseUrl}}/resource_pools/:resource_pool_id');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/resource_pools/:resource_pool_id');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/resource_pools/:resource_pool_id' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource_pools/:resource_pool_id' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/resource_pools/:resource_pool_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resource_pools/:resource_pool_id"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource_pools/:resource_pool_id"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource_pools/:resource_pool_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/resource_pools/:resource_pool_id') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resource_pools/:resource_pool_id";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/resource_pools/:resource_pool_id

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/resource_pools/:resource_pool_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resource_pools/:resource_pool_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resource_pools");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/resource_pools")

require "http/client"

url = "{{baseUrl}}/resource_pools"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/resource_pools"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/resource_pools");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resource_pools"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/resource_pools HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/resource_pools")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resource_pools"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/resource_pools")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/resource_pools")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/resource_pools');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/resource_pools'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resource_pools';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resource_pools',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resource_pools")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource_pools',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/resource_pools'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/resource_pools');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/resource_pools'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resource_pools';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resource_pools"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resource_pools" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resource_pools",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/resource_pools');

echo $response->getBody();

setUrl('{{baseUrl}}/resource_pools');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/resource_pools');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/resource_pools' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource_pools' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/resource_pools")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resource_pools"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource_pools"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource_pools")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/resource_pools') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resource_pools";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/resource_pools

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/resource_pools

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resource_pools")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resource_pools/:resource_pool_id/users");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/resource_pools/:resource_pool_id/users")

require "http/client"

url = "{{baseUrl}}/resource_pools/:resource_pool_id/users"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/resource_pools/:resource_pool_id/users"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/resource_pools/:resource_pool_id/users");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resource_pools/:resource_pool_id/users"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/resource_pools/:resource_pool_id/users HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/resource_pools/:resource_pool_id/users")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resource_pools/:resource_pool_id/users"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/users")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/resource_pools/:resource_pool_id/users")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/resource_pools/:resource_pool_id/users');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/users'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/users';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/users',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/users")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource_pools/:resource_pool_id/users',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/users'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/resource_pools/:resource_pool_id/users');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'GET',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/users'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/users';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resource_pools/:resource_pool_id/users"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resource_pools/:resource_pool_id/users" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resource_pools/:resource_pool_id/users",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/resource_pools/:resource_pool_id/users');

echo $response->getBody();

setUrl('{{baseUrl}}/resource_pools/:resource_pool_id/users');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/resource_pools/:resource_pool_id/users');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/users' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/users' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/resource_pools/:resource_pool_id/users")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resource_pools/:resource_pool_id/users"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource_pools/:resource_pool_id/users"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource_pools/:resource_pool_id/users")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/resource_pools/:resource_pool_id/users') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resource_pools/:resource_pool_id/users";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/resource_pools/:resource_pool_id/users

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/resource_pools/:resource_pool_id/users

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resource_pools/:resource_pool_id/users")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resource_pools/:resource_pool_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/resource_pools/:resource_pool_id")

require "http/client"

url = "{{baseUrl}}/resource_pools/:resource_pool_id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/resource_pools/:resource_pool_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/resource_pools/:resource_pool_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resource_pools/:resource_pool_id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/resource_pools/:resource_pool_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/resource_pools/:resource_pool_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resource_pools/:resource_pool_id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/resource_pools/:resource_pool_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/resource_pools/:resource_pool_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resource_pools/:resource_pool_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resource_pools/:resource_pool_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource_pools/:resource_pool_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/resource_pools/:resource_pool_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resource_pools/:resource_pool_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resource_pools/:resource_pool_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resource_pools/:resource_pool_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resource_pools/:resource_pool_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/resource_pools/:resource_pool_id');

echo $response->getBody();

setUrl('{{baseUrl}}/resource_pools/:resource_pool_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/resource_pools/:resource_pool_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/resource_pools/:resource_pool_id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource_pools/:resource_pool_id' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/resource_pools/:resource_pool_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resource_pools/:resource_pool_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource_pools/:resource_pool_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource_pools/:resource_pool_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/resource_pools/:resource_pool_id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resource_pools/:resource_pool_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/resource_pools/:resource_pool_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/resource_pools/:resource_pool_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resource_pools/:resource_pool_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id")

require "http/client"

url = "{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/resource_pools/:resource_pool_id/users/:user_id HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource_pools/:resource_pool_id/users/:user_id',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id');

echo $response->getBody();

setUrl('{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id');
$request->setMethod(HTTP_METH_DELETE);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/resource_pools/:resource_pool_id/users/:user_id")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id"

response <- VERB("DELETE", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/resource_pools/:resource_pool_id/users/:user_id') do |req|
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE {{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resource_pools/:resource_pool_id/users/:user_id")! 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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resource_pools/:resource_pool_id/users");

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  {\n    \"id\": \"\",\n    \"no_default_access\": false\n  }\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/resource_pools/:resource_pool_id/users" {:content-type :json
                                                                                  :form-params [{:id ""
                                                                                                 :no_default_access false}]})

require "http/client"

url = "{{baseUrl}}/resource_pools/:resource_pool_id/users"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {\n    \"id\": \"\",\n    \"no_default_access\": false\n  }\n]"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/resource_pools/:resource_pool_id/users"),
    Content = new StringContent("[\n  {\n    \"id\": \"\",\n    \"no_default_access\": false\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}}/resource_pools/:resource_pool_id/users");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {\n    \"id\": \"\",\n    \"no_default_access\": false\n  }\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resource_pools/:resource_pool_id/users"

	payload := strings.NewReader("[\n  {\n    \"id\": \"\",\n    \"no_default_access\": false\n  }\n]")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/resource_pools/:resource_pool_id/users HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 56

[
  {
    "id": "",
    "no_default_access": false
  }
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/resource_pools/:resource_pool_id/users")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {\n    \"id\": \"\",\n    \"no_default_access\": false\n  }\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resource_pools/:resource_pool_id/users"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("[\n  {\n    \"id\": \"\",\n    \"no_default_access\": false\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  {\n    \"id\": \"\",\n    \"no_default_access\": false\n  }\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/users")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/resource_pools/:resource_pool_id/users")
  .header("content-type", "application/json")
  .body("[\n  {\n    \"id\": \"\",\n    \"no_default_access\": false\n  }\n]")
  .asString();

const data = JSON.stringify([
  {
    id: '',
    no_default_access: false
  }
]);

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/resource_pools/:resource_pool_id/users');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/users',
  headers: {'content-type': 'application/json'},
  data: [{id: '', no_default_access: false}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/users';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","no_default_access":false}]'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/users',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\n  {\n    "id": "",\n    "no_default_access": false\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  {\n    \"id\": \"\",\n    \"no_default_access\": false\n  }\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id/users")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource_pools/:resource_pool_id/users',
  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([{id: '', no_default_access: false}]));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/users',
  headers: {'content-type': 'application/json'},
  body: [{id: '', no_default_access: false}],
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/resource_pools/:resource_pool_id/users');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {
    id: '',
    no_default_access: false
  }
]);

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id/users',
  headers: {'content-type': 'application/json'},
  data: [{id: '', no_default_access: false}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resource_pools/:resource_pool_id/users';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '[{"id":"","no_default_access":false}]'
};

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 = @[ @{ @"id": @"", @"no_default_access": @NO } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resource_pools/:resource_pool_id/users"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resource_pools/:resource_pool_id/users" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {\n    \"id\": \"\",\n    \"no_default_access\": false\n  }\n]" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resource_pools/:resource_pool_id/users",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    [
        'id' => '',
        'no_default_access' => null
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/resource_pools/:resource_pool_id/users', [
  'body' => '[
  {
    "id": "",
    "no_default_access": false
  }
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resource_pools/:resource_pool_id/users');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    'id' => '',
    'no_default_access' => null
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    'id' => '',
    'no_default_access' => null
  ]
]));
$request->setRequestUrl('{{baseUrl}}/resource_pools/:resource_pool_id/users');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/users' -Method PUT -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": "",
    "no_default_access": false
  }
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource_pools/:resource_pool_id/users' -Method PUT -Headers $headers -ContentType 'application/json' -Body '[
  {
    "id": "",
    "no_default_access": false
  }
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {\n    \"id\": \"\",\n    \"no_default_access\": false\n  }\n]"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/resource_pools/:resource_pool_id/users", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resource_pools/:resource_pool_id/users"

payload = [
    {
        "id": "",
        "no_default_access": False
    }
]
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource_pools/:resource_pool_id/users"

payload <- "[\n  {\n    \"id\": \"\",\n    \"no_default_access\": false\n  }\n]"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource_pools/:resource_pool_id/users")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "[\n  {\n    \"id\": \"\",\n    \"no_default_access\": false\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.put('/baseUrl/resource_pools/:resource_pool_id/users') do |req|
  req.body = "[\n  {\n    \"id\": \"\",\n    \"no_default_access\": false\n  }\n]"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resource_pools/:resource_pool_id/users";

    let payload = (
        json!({
            "id": "",
            "no_default_access": false
        })
    );

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '[
  {
    "id": "",
    "no_default_access": false
  }
]' |  \
  http PUT {{baseUrl}}/resource_pools/:resource_pool_id/users \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '[\n  {\n    "id": "",\n    "no_default_access": false\n  }\n]' \
  --output-document \
  - {{baseUrl}}/resource_pools/:resource_pool_id/users

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  [
    "id": "",
    "no_default_access": false
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resource_pools/:resource_pool_id/users")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resource_pools/:resource_pool_id");

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  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/resource_pools/:resource_pool_id" {:content-type :json
                                                                            :form-params {:quota {:cpu ""
                                                                                                  :memory 0
                                                                                                  :gpu 0
                                                                                                  :id ""}
                                                                                          :classes [{:name ""
                                                                                                     :cpu ""
                                                                                                     :memory 0
                                                                                                     :gpu 0
                                                                                                     :max_storage 0
                                                                                                     :default_storage 0
                                                                                                     :id 0
                                                                                                     :default false
                                                                                                     :tolerations []
                                                                                                     :node_affinities [{:key ""
                                                                                                                        :required_during_scheduling false}]}]
                                                                                          :name ""
                                                                                          :public false
                                                                                          :default false
                                                                                          :remote {}
                                                                                          :idle_threshold 0
                                                                                          :hibernation_threshold 0
                                                                                          :cluster_id ""}})

require "http/client"

url = "{{baseUrl}}/resource_pools/:resource_pool_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/resource_pools/:resource_pool_id"),
    Content = new StringContent("{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\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}}/resource_pools/:resource_pool_id");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resource_pools/:resource_pool_id"

	payload := strings.NewReader("{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/resource_pools/:resource_pool_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 561

{
  "quota": {
    "cpu": "",
    "memory": 0,
    "gpu": 0,
    "id": ""
  },
  "classes": [
    {
      "name": "",
      "cpu": "",
      "memory": 0,
      "gpu": 0,
      "max_storage": 0,
      "default_storage": 0,
      "id": 0,
      "default": false,
      "tolerations": [],
      "node_affinities": [
        {
          "key": "",
          "required_during_scheduling": false
        }
      ]
    }
  ],
  "name": "",
  "public": false,
  "default": false,
  "remote": {},
  "idle_threshold": 0,
  "hibernation_threshold": 0,
  "cluster_id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/resource_pools/:resource_pool_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resource_pools/:resource_pool_id"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\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  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/resource_pools/:resource_pool_id")
  .header("content-type", "application/json")
  .body("{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  quota: {
    cpu: '',
    memory: 0,
    gpu: 0,
    id: ''
  },
  classes: [
    {
      name: '',
      cpu: '',
      memory: 0,
      gpu: 0,
      max_storage: 0,
      default_storage: 0,
      id: 0,
      default: false,
      tolerations: [],
      node_affinities: [
        {
          key: '',
          required_during_scheduling: false
        }
      ]
    }
  ],
  name: '',
  public: false,
  default: false,
  remote: {},
  idle_threshold: 0,
  hibernation_threshold: 0,
  cluster_id: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/resource_pools/:resource_pool_id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id',
  headers: {'content-type': 'application/json'},
  data: {
    quota: {cpu: '', memory: 0, gpu: 0, id: ''},
    classes: [
      {
        name: '',
        cpu: '',
        memory: 0,
        gpu: 0,
        max_storage: 0,
        default_storage: 0,
        id: 0,
        default: false,
        tolerations: [],
        node_affinities: [{key: '', required_during_scheduling: false}]
      }
    ],
    name: '',
    public: false,
    default: false,
    remote: {},
    idle_threshold: 0,
    hibernation_threshold: 0,
    cluster_id: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resource_pools/:resource_pool_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"quota":{"cpu":"","memory":0,"gpu":0,"id":""},"classes":[{"name":"","cpu":"","memory":0,"gpu":0,"max_storage":0,"default_storage":0,"id":0,"default":false,"tolerations":[],"node_affinities":[{"key":"","required_during_scheduling":false}]}],"name":"","public":false,"default":false,"remote":{},"idle_threshold":0,"hibernation_threshold":0,"cluster_id":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resource_pools/:resource_pool_id',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "quota": {\n    "cpu": "",\n    "memory": 0,\n    "gpu": 0,\n    "id": ""\n  },\n  "classes": [\n    {\n      "name": "",\n      "cpu": "",\n      "memory": 0,\n      "gpu": 0,\n      "max_storage": 0,\n      "default_storage": 0,\n      "id": 0,\n      "default": false,\n      "tolerations": [],\n      "node_affinities": [\n        {\n          "key": "",\n          "required_during_scheduling": false\n        }\n      ]\n    }\n  ],\n  "name": "",\n  "public": false,\n  "default": false,\n  "remote": {},\n  "idle_threshold": 0,\n  "hibernation_threshold": 0,\n  "cluster_id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource_pools/:resource_pool_id',
  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({
  quota: {cpu: '', memory: 0, gpu: 0, id: ''},
  classes: [
    {
      name: '',
      cpu: '',
      memory: 0,
      gpu: 0,
      max_storage: 0,
      default_storage: 0,
      id: 0,
      default: false,
      tolerations: [],
      node_affinities: [{key: '', required_during_scheduling: false}]
    }
  ],
  name: '',
  public: false,
  default: false,
  remote: {},
  idle_threshold: 0,
  hibernation_threshold: 0,
  cluster_id: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id',
  headers: {'content-type': 'application/json'},
  body: {
    quota: {cpu: '', memory: 0, gpu: 0, id: ''},
    classes: [
      {
        name: '',
        cpu: '',
        memory: 0,
        gpu: 0,
        max_storage: 0,
        default_storage: 0,
        id: 0,
        default: false,
        tolerations: [],
        node_affinities: [{key: '', required_during_scheduling: false}]
      }
    ],
    name: '',
    public: false,
    default: false,
    remote: {},
    idle_threshold: 0,
    hibernation_threshold: 0,
    cluster_id: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/resource_pools/:resource_pool_id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  quota: {
    cpu: '',
    memory: 0,
    gpu: 0,
    id: ''
  },
  classes: [
    {
      name: '',
      cpu: '',
      memory: 0,
      gpu: 0,
      max_storage: 0,
      default_storage: 0,
      id: 0,
      default: false,
      tolerations: [],
      node_affinities: [
        {
          key: '',
          required_during_scheduling: false
        }
      ]
    }
  ],
  name: '',
  public: false,
  default: false,
  remote: {},
  idle_threshold: 0,
  hibernation_threshold: 0,
  cluster_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id',
  headers: {'content-type': 'application/json'},
  data: {
    quota: {cpu: '', memory: 0, gpu: 0, id: ''},
    classes: [
      {
        name: '',
        cpu: '',
        memory: 0,
        gpu: 0,
        max_storage: 0,
        default_storage: 0,
        id: 0,
        default: false,
        tolerations: [],
        node_affinities: [{key: '', required_during_scheduling: false}]
      }
    ],
    name: '',
    public: false,
    default: false,
    remote: {},
    idle_threshold: 0,
    hibernation_threshold: 0,
    cluster_id: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resource_pools/:resource_pool_id';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"quota":{"cpu":"","memory":0,"gpu":0,"id":""},"classes":[{"name":"","cpu":"","memory":0,"gpu":0,"max_storage":0,"default_storage":0,"id":0,"default":false,"tolerations":[],"node_affinities":[{"key":"","required_during_scheduling":false}]}],"name":"","public":false,"default":false,"remote":{},"idle_threshold":0,"hibernation_threshold":0,"cluster_id":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"quota": @{ @"cpu": @"", @"memory": @0, @"gpu": @0, @"id": @"" },
                              @"classes": @[ @{ @"name": @"", @"cpu": @"", @"memory": @0, @"gpu": @0, @"max_storage": @0, @"default_storage": @0, @"id": @0, @"default": @NO, @"tolerations": @[  ], @"node_affinities": @[ @{ @"key": @"", @"required_during_scheduling": @NO } ] } ],
                              @"name": @"",
                              @"public": @NO,
                              @"default": @NO,
                              @"remote": @{  },
                              @"idle_threshold": @0,
                              @"hibernation_threshold": @0,
                              @"cluster_id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resource_pools/:resource_pool_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resource_pools/:resource_pool_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resource_pools/:resource_pool_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    'quota' => [
        'cpu' => '',
        'memory' => 0,
        'gpu' => 0,
        'id' => ''
    ],
    'classes' => [
        [
                'name' => '',
                'cpu' => '',
                'memory' => 0,
                'gpu' => 0,
                'max_storage' => 0,
                'default_storage' => 0,
                'id' => 0,
                'default' => null,
                'tolerations' => [
                                
                ],
                'node_affinities' => [
                                [
                                                                'key' => '',
                                                                'required_during_scheduling' => null
                                ]
                ]
        ]
    ],
    'name' => '',
    'public' => null,
    'default' => null,
    'remote' => [
        
    ],
    'idle_threshold' => 0,
    'hibernation_threshold' => 0,
    'cluster_id' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/resource_pools/:resource_pool_id', [
  'body' => '{
  "quota": {
    "cpu": "",
    "memory": 0,
    "gpu": 0,
    "id": ""
  },
  "classes": [
    {
      "name": "",
      "cpu": "",
      "memory": 0,
      "gpu": 0,
      "max_storage": 0,
      "default_storage": 0,
      "id": 0,
      "default": false,
      "tolerations": [],
      "node_affinities": [
        {
          "key": "",
          "required_during_scheduling": false
        }
      ]
    }
  ],
  "name": "",
  "public": false,
  "default": false,
  "remote": {},
  "idle_threshold": 0,
  "hibernation_threshold": 0,
  "cluster_id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resource_pools/:resource_pool_id');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'quota' => [
    'cpu' => '',
    'memory' => 0,
    'gpu' => 0,
    'id' => ''
  ],
  'classes' => [
    [
        'name' => '',
        'cpu' => '',
        'memory' => 0,
        'gpu' => 0,
        'max_storage' => 0,
        'default_storage' => 0,
        'id' => 0,
        'default' => null,
        'tolerations' => [
                
        ],
        'node_affinities' => [
                [
                                'key' => '',
                                'required_during_scheduling' => null
                ]
        ]
    ]
  ],
  'name' => '',
  'public' => null,
  'default' => null,
  'remote' => [
    
  ],
  'idle_threshold' => 0,
  'hibernation_threshold' => 0,
  'cluster_id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'quota' => [
    'cpu' => '',
    'memory' => 0,
    'gpu' => 0,
    'id' => ''
  ],
  'classes' => [
    [
        'name' => '',
        'cpu' => '',
        'memory' => 0,
        'gpu' => 0,
        'max_storage' => 0,
        'default_storage' => 0,
        'id' => 0,
        'default' => null,
        'tolerations' => [
                
        ],
        'node_affinities' => [
                [
                                'key' => '',
                                'required_during_scheduling' => null
                ]
        ]
    ]
  ],
  'name' => '',
  'public' => null,
  'default' => null,
  'remote' => [
    
  ],
  'idle_threshold' => 0,
  'hibernation_threshold' => 0,
  'cluster_id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/resource_pools/:resource_pool_id');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/resource_pools/:resource_pool_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "quota": {
    "cpu": "",
    "memory": 0,
    "gpu": 0,
    "id": ""
  },
  "classes": [
    {
      "name": "",
      "cpu": "",
      "memory": 0,
      "gpu": 0,
      "max_storage": 0,
      "default_storage": 0,
      "id": 0,
      "default": false,
      "tolerations": [],
      "node_affinities": [
        {
          "key": "",
          "required_during_scheduling": false
        }
      ]
    }
  ],
  "name": "",
  "public": false,
  "default": false,
  "remote": {},
  "idle_threshold": 0,
  "hibernation_threshold": 0,
  "cluster_id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource_pools/:resource_pool_id' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "quota": {
    "cpu": "",
    "memory": 0,
    "gpu": 0,
    "id": ""
  },
  "classes": [
    {
      "name": "",
      "cpu": "",
      "memory": 0,
      "gpu": 0,
      "max_storage": 0,
      "default_storage": 0,
      "id": 0,
      "default": false,
      "tolerations": [],
      "node_affinities": [
        {
          "key": "",
          "required_during_scheduling": false
        }
      ]
    }
  ],
  "name": "",
  "public": false,
  "default": false,
  "remote": {},
  "idle_threshold": 0,
  "hibernation_threshold": 0,
  "cluster_id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/resource_pools/:resource_pool_id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resource_pools/:resource_pool_id"

payload = {
    "quota": {
        "cpu": "",
        "memory": 0,
        "gpu": 0,
        "id": ""
    },
    "classes": [
        {
            "name": "",
            "cpu": "",
            "memory": 0,
            "gpu": 0,
            "max_storage": 0,
            "default_storage": 0,
            "id": 0,
            "default": False,
            "tolerations": [],
            "node_affinities": [
                {
                    "key": "",
                    "required_during_scheduling": False
                }
            ]
        }
    ],
    "name": "",
    "public": False,
    "default": False,
    "remote": {},
    "idle_threshold": 0,
    "hibernation_threshold": 0,
    "cluster_id": ""
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource_pools/:resource_pool_id"

payload <- "{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource_pools/:resource_pool_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/resource_pools/:resource_pool_id') do |req|
  req.body = "{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0,\n    \"id\": \"\"\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resource_pools/:resource_pool_id";

    let payload = json!({
        "quota": json!({
            "cpu": "",
            "memory": 0,
            "gpu": 0,
            "id": ""
        }),
        "classes": (
            json!({
                "name": "",
                "cpu": "",
                "memory": 0,
                "gpu": 0,
                "max_storage": 0,
                "default_storage": 0,
                "id": 0,
                "default": false,
                "tolerations": (),
                "node_affinities": (
                    json!({
                        "key": "",
                        "required_during_scheduling": false
                    })
                )
            })
        ),
        "name": "",
        "public": false,
        "default": false,
        "remote": json!({}),
        "idle_threshold": 0,
        "hibernation_threshold": 0,
        "cluster_id": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "quota": {
    "cpu": "",
    "memory": 0,
    "gpu": 0,
    "id": ""
  },
  "classes": [
    {
      "name": "",
      "cpu": "",
      "memory": 0,
      "gpu": 0,
      "max_storage": 0,
      "default_storage": 0,
      "id": 0,
      "default": false,
      "tolerations": [],
      "node_affinities": [
        {
          "key": "",
          "required_during_scheduling": false
        }
      ]
    }
  ],
  "name": "",
  "public": false,
  "default": false,
  "remote": {},
  "idle_threshold": 0,
  "hibernation_threshold": 0,
  "cluster_id": ""
}' |  \
  http PUT {{baseUrl}}/resource_pools/:resource_pool_id \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "quota": {\n    "cpu": "",\n    "memory": 0,\n    "gpu": 0,\n    "id": ""\n  },\n  "classes": [\n    {\n      "name": "",\n      "cpu": "",\n      "memory": 0,\n      "gpu": 0,\n      "max_storage": 0,\n      "default_storage": 0,\n      "id": 0,\n      "default": false,\n      "tolerations": [],\n      "node_affinities": [\n        {\n          "key": "",\n          "required_during_scheduling": false\n        }\n      ]\n    }\n  ],\n  "name": "",\n  "public": false,\n  "default": false,\n  "remote": {},\n  "idle_threshold": 0,\n  "hibernation_threshold": 0,\n  "cluster_id": ""\n}' \
  --output-document \
  - {{baseUrl}}/resource_pools/:resource_pool_id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "quota": [
    "cpu": "",
    "memory": 0,
    "gpu": 0,
    "id": ""
  ],
  "classes": [
    [
      "name": "",
      "cpu": "",
      "memory": 0,
      "gpu": 0,
      "max_storage": 0,
      "default_storage": 0,
      "id": 0,
      "default": false,
      "tolerations": [],
      "node_affinities": [
        [
          "key": "",
          "required_during_scheduling": false
        ]
      ]
    ]
  ],
  "name": "",
  "public": false,
  "default": false,
  "remote": [],
  "idle_threshold": 0,
  "hibernation_threshold": 0,
  "cluster_id": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resource_pools/:resource_pool_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PATCH");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/resource_pools/:resource_pool_id");

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  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/patch "{{baseUrl}}/resource_pools/:resource_pool_id" {:content-type :json
                                                                              :form-params {:quota {:cpu ""
                                                                                                    :memory 0
                                                                                                    :gpu 0}
                                                                                            :classes [{:name ""
                                                                                                       :cpu ""
                                                                                                       :memory 0
                                                                                                       :gpu 0
                                                                                                       :max_storage 0
                                                                                                       :default_storage 0
                                                                                                       :id 0
                                                                                                       :default false
                                                                                                       :tolerations []
                                                                                                       :node_affinities [{:key ""
                                                                                                                          :required_during_scheduling false}]}]
                                                                                            :name ""
                                                                                            :public false
                                                                                            :default false
                                                                                            :remote {}
                                                                                            :idle_threshold 0
                                                                                            :hibernation_threshold 0
                                                                                            :cluster_id ""}})

require "http/client"

url = "{{baseUrl}}/resource_pools/:resource_pool_id"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}"

response = HTTP::Client.patch url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Patch,
    RequestUri = new Uri("{{baseUrl}}/resource_pools/:resource_pool_id"),
    Content = new StringContent("{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\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}}/resource_pools/:resource_pool_id");
var request = new RestRequest("", Method.Patch);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/resource_pools/:resource_pool_id"

	payload := strings.NewReader("{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}")

	req, _ := http.NewRequest("PATCH", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PATCH /baseUrl/resource_pools/:resource_pool_id HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 547

{
  "quota": {
    "cpu": "",
    "memory": 0,
    "gpu": 0
  },
  "classes": [
    {
      "name": "",
      "cpu": "",
      "memory": 0,
      "gpu": 0,
      "max_storage": 0,
      "default_storage": 0,
      "id": 0,
      "default": false,
      "tolerations": [],
      "node_affinities": [
        {
          "key": "",
          "required_during_scheduling": false
        }
      ]
    }
  ],
  "name": "",
  "public": false,
  "default": false,
  "remote": {},
  "idle_threshold": 0,
  "hibernation_threshold": 0,
  "cluster_id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PATCH", "{{baseUrl}}/resource_pools/:resource_pool_id")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/resource_pools/:resource_pool_id"))
    .header("content-type", "application/json")
    .method("PATCH", HttpRequest.BodyPublishers.ofString("{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\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  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.patch("{{baseUrl}}/resource_pools/:resource_pool_id")
  .header("content-type", "application/json")
  .body("{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  quota: {
    cpu: '',
    memory: 0,
    gpu: 0
  },
  classes: [
    {
      name: '',
      cpu: '',
      memory: 0,
      gpu: 0,
      max_storage: 0,
      default_storage: 0,
      id: 0,
      default: false,
      tolerations: [],
      node_affinities: [
        {
          key: '',
          required_during_scheduling: false
        }
      ]
    }
  ],
  name: '',
  public: false,
  default: false,
  remote: {},
  idle_threshold: 0,
  hibernation_threshold: 0,
  cluster_id: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PATCH', '{{baseUrl}}/resource_pools/:resource_pool_id');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id',
  headers: {'content-type': 'application/json'},
  data: {
    quota: {cpu: '', memory: 0, gpu: 0},
    classes: [
      {
        name: '',
        cpu: '',
        memory: 0,
        gpu: 0,
        max_storage: 0,
        default_storage: 0,
        id: 0,
        default: false,
        tolerations: [],
        node_affinities: [{key: '', required_during_scheduling: false}]
      }
    ],
    name: '',
    public: false,
    default: false,
    remote: {},
    idle_threshold: 0,
    hibernation_threshold: 0,
    cluster_id: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/resource_pools/:resource_pool_id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"quota":{"cpu":"","memory":0,"gpu":0},"classes":[{"name":"","cpu":"","memory":0,"gpu":0,"max_storage":0,"default_storage":0,"id":0,"default":false,"tolerations":[],"node_affinities":[{"key":"","required_during_scheduling":false}]}],"name":"","public":false,"default":false,"remote":{},"idle_threshold":0,"hibernation_threshold":0,"cluster_id":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/resource_pools/:resource_pool_id',
  method: 'PATCH',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "quota": {\n    "cpu": "",\n    "memory": 0,\n    "gpu": 0\n  },\n  "classes": [\n    {\n      "name": "",\n      "cpu": "",\n      "memory": 0,\n      "gpu": 0,\n      "max_storage": 0,\n      "default_storage": 0,\n      "id": 0,\n      "default": false,\n      "tolerations": [],\n      "node_affinities": [\n        {\n          "key": "",\n          "required_during_scheduling": false\n        }\n      ]\n    }\n  ],\n  "name": "",\n  "public": false,\n  "default": false,\n  "remote": {},\n  "idle_threshold": 0,\n  "hibernation_threshold": 0,\n  "cluster_id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/resource_pools/:resource_pool_id")
  .patch(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PATCH',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/resource_pools/:resource_pool_id',
  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({
  quota: {cpu: '', memory: 0, gpu: 0},
  classes: [
    {
      name: '',
      cpu: '',
      memory: 0,
      gpu: 0,
      max_storage: 0,
      default_storage: 0,
      id: 0,
      default: false,
      tolerations: [],
      node_affinities: [{key: '', required_during_scheduling: false}]
    }
  ],
  name: '',
  public: false,
  default: false,
  remote: {},
  idle_threshold: 0,
  hibernation_threshold: 0,
  cluster_id: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id',
  headers: {'content-type': 'application/json'},
  body: {
    quota: {cpu: '', memory: 0, gpu: 0},
    classes: [
      {
        name: '',
        cpu: '',
        memory: 0,
        gpu: 0,
        max_storage: 0,
        default_storage: 0,
        id: 0,
        default: false,
        tolerations: [],
        node_affinities: [{key: '', required_during_scheduling: false}]
      }
    ],
    name: '',
    public: false,
    default: false,
    remote: {},
    idle_threshold: 0,
    hibernation_threshold: 0,
    cluster_id: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PATCH', '{{baseUrl}}/resource_pools/:resource_pool_id');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  quota: {
    cpu: '',
    memory: 0,
    gpu: 0
  },
  classes: [
    {
      name: '',
      cpu: '',
      memory: 0,
      gpu: 0,
      max_storage: 0,
      default_storage: 0,
      id: 0,
      default: false,
      tolerations: [],
      node_affinities: [
        {
          key: '',
          required_during_scheduling: false
        }
      ]
    }
  ],
  name: '',
  public: false,
  default: false,
  remote: {},
  idle_threshold: 0,
  hibernation_threshold: 0,
  cluster_id: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PATCH',
  url: '{{baseUrl}}/resource_pools/:resource_pool_id',
  headers: {'content-type': 'application/json'},
  data: {
    quota: {cpu: '', memory: 0, gpu: 0},
    classes: [
      {
        name: '',
        cpu: '',
        memory: 0,
        gpu: 0,
        max_storage: 0,
        default_storage: 0,
        id: 0,
        default: false,
        tolerations: [],
        node_affinities: [{key: '', required_during_scheduling: false}]
      }
    ],
    name: '',
    public: false,
    default: false,
    remote: {},
    idle_threshold: 0,
    hibernation_threshold: 0,
    cluster_id: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/resource_pools/:resource_pool_id';
const options = {
  method: 'PATCH',
  headers: {'content-type': 'application/json'},
  body: '{"quota":{"cpu":"","memory":0,"gpu":0},"classes":[{"name":"","cpu":"","memory":0,"gpu":0,"max_storage":0,"default_storage":0,"id":0,"default":false,"tolerations":[],"node_affinities":[{"key":"","required_during_scheduling":false}]}],"name":"","public":false,"default":false,"remote":{},"idle_threshold":0,"hibernation_threshold":0,"cluster_id":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"quota": @{ @"cpu": @"", @"memory": @0, @"gpu": @0 },
                              @"classes": @[ @{ @"name": @"", @"cpu": @"", @"memory": @0, @"gpu": @0, @"max_storage": @0, @"default_storage": @0, @"id": @0, @"default": @NO, @"tolerations": @[  ], @"node_affinities": @[ @{ @"key": @"", @"required_during_scheduling": @NO } ] } ],
                              @"name": @"",
                              @"public": @NO,
                              @"default": @NO,
                              @"remote": @{  },
                              @"idle_threshold": @0,
                              @"hibernation_threshold": @0,
                              @"cluster_id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/resource_pools/:resource_pool_id"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/resource_pools/:resource_pool_id" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}" in

Client.call ~headers ~body `PATCH uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/resource_pools/:resource_pool_id",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PATCH",
  CURLOPT_POSTFIELDS => json_encode([
    'quota' => [
        'cpu' => '',
        'memory' => 0,
        'gpu' => 0
    ],
    'classes' => [
        [
                'name' => '',
                'cpu' => '',
                'memory' => 0,
                'gpu' => 0,
                'max_storage' => 0,
                'default_storage' => 0,
                'id' => 0,
                'default' => null,
                'tolerations' => [
                                
                ],
                'node_affinities' => [
                                [
                                                                'key' => '',
                                                                'required_during_scheduling' => null
                                ]
                ]
        ]
    ],
    'name' => '',
    'public' => null,
    'default' => null,
    'remote' => [
        
    ],
    'idle_threshold' => 0,
    'hibernation_threshold' => 0,
    'cluster_id' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PATCH', '{{baseUrl}}/resource_pools/:resource_pool_id', [
  'body' => '{
  "quota": {
    "cpu": "",
    "memory": 0,
    "gpu": 0
  },
  "classes": [
    {
      "name": "",
      "cpu": "",
      "memory": 0,
      "gpu": 0,
      "max_storage": 0,
      "default_storage": 0,
      "id": 0,
      "default": false,
      "tolerations": [],
      "node_affinities": [
        {
          "key": "",
          "required_during_scheduling": false
        }
      ]
    }
  ],
  "name": "",
  "public": false,
  "default": false,
  "remote": {},
  "idle_threshold": 0,
  "hibernation_threshold": 0,
  "cluster_id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/resource_pools/:resource_pool_id');
$request->setMethod(HttpRequest::HTTP_METH_PATCH);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'quota' => [
    'cpu' => '',
    'memory' => 0,
    'gpu' => 0
  ],
  'classes' => [
    [
        'name' => '',
        'cpu' => '',
        'memory' => 0,
        'gpu' => 0,
        'max_storage' => 0,
        'default_storage' => 0,
        'id' => 0,
        'default' => null,
        'tolerations' => [
                
        ],
        'node_affinities' => [
                [
                                'key' => '',
                                'required_during_scheduling' => null
                ]
        ]
    ]
  ],
  'name' => '',
  'public' => null,
  'default' => null,
  'remote' => [
    
  ],
  'idle_threshold' => 0,
  'hibernation_threshold' => 0,
  'cluster_id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'quota' => [
    'cpu' => '',
    'memory' => 0,
    'gpu' => 0
  ],
  'classes' => [
    [
        'name' => '',
        'cpu' => '',
        'memory' => 0,
        'gpu' => 0,
        'max_storage' => 0,
        'default_storage' => 0,
        'id' => 0,
        'default' => null,
        'tolerations' => [
                
        ],
        'node_affinities' => [
                [
                                'key' => '',
                                'required_during_scheduling' => null
                ]
        ]
    ]
  ],
  'name' => '',
  'public' => null,
  'default' => null,
  'remote' => [
    
  ],
  'idle_threshold' => 0,
  'hibernation_threshold' => 0,
  'cluster_id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/resource_pools/:resource_pool_id');
$request->setRequestMethod('PATCH');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/resource_pools/:resource_pool_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "quota": {
    "cpu": "",
    "memory": 0,
    "gpu": 0
  },
  "classes": [
    {
      "name": "",
      "cpu": "",
      "memory": 0,
      "gpu": 0,
      "max_storage": 0,
      "default_storage": 0,
      "id": 0,
      "default": false,
      "tolerations": [],
      "node_affinities": [
        {
          "key": "",
          "required_during_scheduling": false
        }
      ]
    }
  ],
  "name": "",
  "public": false,
  "default": false,
  "remote": {},
  "idle_threshold": 0,
  "hibernation_threshold": 0,
  "cluster_id": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/resource_pools/:resource_pool_id' -Method PATCH -Headers $headers -ContentType 'application/json' -Body '{
  "quota": {
    "cpu": "",
    "memory": 0,
    "gpu": 0
  },
  "classes": [
    {
      "name": "",
      "cpu": "",
      "memory": 0,
      "gpu": 0,
      "max_storage": 0,
      "default_storage": 0,
      "id": 0,
      "default": false,
      "tolerations": [],
      "node_affinities": [
        {
          "key": "",
          "required_during_scheduling": false
        }
      ]
    }
  ],
  "name": "",
  "public": false,
  "default": false,
  "remote": {},
  "idle_threshold": 0,
  "hibernation_threshold": 0,
  "cluster_id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PATCH", "/baseUrl/resource_pools/:resource_pool_id", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/resource_pools/:resource_pool_id"

payload = {
    "quota": {
        "cpu": "",
        "memory": 0,
        "gpu": 0
    },
    "classes": [
        {
            "name": "",
            "cpu": "",
            "memory": 0,
            "gpu": 0,
            "max_storage": 0,
            "default_storage": 0,
            "id": 0,
            "default": False,
            "tolerations": [],
            "node_affinities": [
                {
                    "key": "",
                    "required_during_scheduling": False
                }
            ]
        }
    ],
    "name": "",
    "public": False,
    "default": False,
    "remote": {},
    "idle_threshold": 0,
    "hibernation_threshold": 0,
    "cluster_id": ""
}
headers = {"content-type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/resource_pools/:resource_pool_id"

payload <- "{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}"

encode <- "json"

response <- VERB("PATCH", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/resource_pools/:resource_pool_id")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.patch('/baseUrl/resource_pools/:resource_pool_id') do |req|
  req.body = "{\n  \"quota\": {\n    \"cpu\": \"\",\n    \"memory\": 0,\n    \"gpu\": 0\n  },\n  \"classes\": [\n    {\n      \"name\": \"\",\n      \"cpu\": \"\",\n      \"memory\": 0,\n      \"gpu\": 0,\n      \"max_storage\": 0,\n      \"default_storage\": 0,\n      \"id\": 0,\n      \"default\": false,\n      \"tolerations\": [],\n      \"node_affinities\": [\n        {\n          \"key\": \"\",\n          \"required_during_scheduling\": false\n        }\n      ]\n    }\n  ],\n  \"name\": \"\",\n  \"public\": false,\n  \"default\": false,\n  \"remote\": {},\n  \"idle_threshold\": 0,\n  \"hibernation_threshold\": 0,\n  \"cluster_id\": \"\"\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/resource_pools/:resource_pool_id";

    let payload = json!({
        "quota": json!({
            "cpu": "",
            "memory": 0,
            "gpu": 0
        }),
        "classes": (
            json!({
                "name": "",
                "cpu": "",
                "memory": 0,
                "gpu": 0,
                "max_storage": 0,
                "default_storage": 0,
                "id": 0,
                "default": false,
                "tolerations": (),
                "node_affinities": (
                    json!({
                        "key": "",
                        "required_during_scheduling": false
                    })
                )
            })
        ),
        "name": "",
        "public": false,
        "default": false,
        "remote": json!({}),
        "idle_threshold": 0,
        "hibernation_threshold": 0,
        "cluster_id": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PATCH").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "quota": {
    "cpu": "",
    "memory": 0,
    "gpu": 0
  },
  "classes": [
    {
      "name": "",
      "cpu": "",
      "memory": 0,
      "gpu": 0,
      "max_storage": 0,
      "default_storage": 0,
      "id": 0,
      "default": false,
      "tolerations": [],
      "node_affinities": [
        {
          "key": "",
          "required_during_scheduling": false
        }
      ]
    }
  ],
  "name": "",
  "public": false,
  "default": false,
  "remote": {},
  "idle_threshold": 0,
  "hibernation_threshold": 0,
  "cluster_id": ""
}' |  \
  http PATCH {{baseUrl}}/resource_pools/:resource_pool_id \
  content-type:application/json

wget --quiet \
  --method PATCH \
  --header 'content-type: application/json' \
  --body-data '{\n  "quota": {\n    "cpu": "",\n    "memory": 0,\n    "gpu": 0\n  },\n  "classes": [\n    {\n      "name": "",\n      "cpu": "",\n      "memory": 0,\n      "gpu": 0,\n      "max_storage": 0,\n      "default_storage": 0,\n      "id": 0,\n      "default": false,\n      "tolerations": [],\n      "node_affinities": [\n        {\n          "key": "",\n          "required_during_scheduling": false\n        }\n      ]\n    }\n  ],\n  "name": "",\n  "public": false,\n  "default": false,\n  "remote": {},\n  "idle_threshold": 0,\n  "hibernation_threshold": 0,\n  "cluster_id": ""\n}' \
  --output-document \
  - {{baseUrl}}/resource_pools/:resource_pool_id

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "quota": [
    "cpu": "",
    "memory": 0,
    "gpu": 0
  ],
  "classes": [
    [
      "name": "",
      "cpu": "",
      "memory": 0,
      "gpu": 0,
      "max_storage": 0,
      "default_storage": 0,
      "id": 0,
      "default": false,
      "tolerations": [],
      "node_affinities": [
        [
          "key": "",
          "required_during_scheduling": false
        ]
      ]
    ]
  ],
  "name": "",
  "public": false,
  "default": false,
  "remote": [],
  "idle_threshold": 0,
  "hibernation_threshold": 0,
  "cluster_id": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/resource_pools/:resource_pool_id")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users/:user_id/resource_pools");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/users/:user_id/resource_pools")

require "http/client"

url = "{{baseUrl}}/users/:user_id/resource_pools"

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}}/users/:user_id/resource_pools"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/users/:user_id/resource_pools");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/users/:user_id/resource_pools"

	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/users/:user_id/resource_pools HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/users/:user_id/resource_pools")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/users/:user_id/resource_pools"))
    .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}}/users/:user_id/resource_pools")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/users/:user_id/resource_pools")
  .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}}/users/:user_id/resource_pools');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/users/:user_id/resource_pools'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/users/:user_id/resource_pools';
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}}/users/:user_id/resource_pools',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/users/:user_id/resource_pools")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/users/:user_id/resource_pools',
  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}}/users/:user_id/resource_pools'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/users/:user_id/resource_pools');

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}}/users/:user_id/resource_pools'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/users/:user_id/resource_pools';
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}}/users/:user_id/resource_pools"]
                                                       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}}/users/:user_id/resource_pools" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/users/:user_id/resource_pools",
  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}}/users/:user_id/resource_pools');

echo $response->getBody();

setUrl('{{baseUrl}}/users/:user_id/resource_pools');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/users/:user_id/resource_pools');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/users/:user_id/resource_pools' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/users/:user_id/resource_pools' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/users/:user_id/resource_pools")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/users/:user_id/resource_pools"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/users/:user_id/resource_pools"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/users/:user_id/resource_pools")

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/users/:user_id/resource_pools') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/users/:user_id/resource_pools";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/users/:user_id/resource_pools

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/users/:user_id/resource_pools

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/:user_id/resource_pools")! 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}}/users/:user_id/resource_pools");

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  {}\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/users/:user_id/resource_pools" {:content-type :json
                                                                          :form-params [{}]})

require "http/client"

url = "{{baseUrl}}/users/:user_id/resource_pools"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\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}}/users/:user_id/resource_pools"),
    Content = new StringContent("[\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}}/users/:user_id/resource_pools");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {}\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/users/:user_id/resource_pools"

	payload := strings.NewReader("[\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/users/:user_id/resource_pools HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 8

[
  {}
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/users/:user_id/resource_pools")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {}\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/users/:user_id/resource_pools"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("[\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  {}\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/users/:user_id/resource_pools")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/users/:user_id/resource_pools")
  .header("content-type", "application/json")
  .body("[\n  {}\n]")
  .asString();

const data = JSON.stringify([
  {}
]);

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/users/:user_id/resource_pools');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/users/:user_id/resource_pools',
  headers: {'content-type': 'application/json'},
  data: [{}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/users/:user_id/resource_pools';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '[{}]'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/users/:user_id/resource_pools',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\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  {}\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/users/:user_id/resource_pools")
  .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/users/:user_id/resource_pools',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify([{}]));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/users/:user_id/resource_pools',
  headers: {'content-type': 'application/json'},
  body: [{}],
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/users/:user_id/resource_pools');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {}
]);

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/users/:user_id/resource_pools',
  headers: {'content-type': 'application/json'},
  data: [{}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/users/:user_id/resource_pools';
const options = {method: 'POST', headers: {'content-type': 'application/json'}, body: '[{}]'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @[ @{  } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/users/:user_id/resource_pools"]
                                                       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}}/users/:user_id/resource_pools" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {}\n]" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/users/:user_id/resource_pools",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/users/:user_id/resource_pools', [
  'body' => '[
  {}
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/users/:user_id/resource_pools');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/users/:user_id/resource_pools');
$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}}/users/:user_id/resource_pools' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {}
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/users/:user_id/resource_pools' -Method POST -Headers $headers -ContentType 'application/json' -Body '[
  {}
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {}\n]"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/users/:user_id/resource_pools", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/users/:user_id/resource_pools"

payload = [{}]
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/users/:user_id/resource_pools"

payload <- "[\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}}/users/:user_id/resource_pools")

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  {}\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/users/:user_id/resource_pools') do |req|
  req.body = "[\n  {}\n]"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/users/:user_id/resource_pools";

    let payload = (json!({}));

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '[
  {}
]' |  \
  http POST {{baseUrl}}/users/:user_id/resource_pools \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '[\n  {}\n]' \
  --output-document \
  - {{baseUrl}}/users/:user_id/resource_pools

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [[]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/:user_id/resource_pools")! 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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/users/:user_id/resource_pools");

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  {}\n]");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/users/:user_id/resource_pools" {:content-type :json
                                                                         :form-params [{}]})

require "http/client"

url = "{{baseUrl}}/users/:user_id/resource_pools"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "[\n  {}\n]"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/users/:user_id/resource_pools"),
    Content = new StringContent("[\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}}/users/:user_id/resource_pools");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "[\n  {}\n]", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/users/:user_id/resource_pools"

	payload := strings.NewReader("[\n  {}\n]")

	req, _ := http.NewRequest("PUT", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/users/:user_id/resource_pools HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 8

[
  {}
]

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/users/:user_id/resource_pools")
  .setHeader("content-type", "application/json")
  .setBody("[\n  {}\n]")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/users/:user_id/resource_pools"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("[\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  {}\n]");
Request request = new Request.Builder()
  .url("{{baseUrl}}/users/:user_id/resource_pools")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/users/:user_id/resource_pools")
  .header("content-type", "application/json")
  .body("[\n  {}\n]")
  .asString();

const data = JSON.stringify([
  {}
]);

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/users/:user_id/resource_pools');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/users/:user_id/resource_pools',
  headers: {'content-type': 'application/json'},
  data: [{}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/users/:user_id/resource_pools';
const options = {method: 'PUT', headers: {'content-type': 'application/json'}, body: '[{}]'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/users/:user_id/resource_pools',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '[\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  {}\n]")
val request = Request.Builder()
  .url("{{baseUrl}}/users/:user_id/resource_pools")
  .put(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/users/:user_id/resource_pools',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify([{}]));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/users/:user_id/resource_pools',
  headers: {'content-type': 'application/json'},
  body: [{}],
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/users/:user_id/resource_pools');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send([
  {}
]);

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/users/:user_id/resource_pools',
  headers: {'content-type': 'application/json'},
  data: [{}]
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/users/:user_id/resource_pools';
const options = {method: 'PUT', headers: {'content-type': 'application/json'}, body: '[{}]'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @[ @{  } ];

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/users/:user_id/resource_pools"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/users/:user_id/resource_pools" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "[\n  {}\n]" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/users/:user_id/resource_pools",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
  CURLOPT_POSTFIELDS => json_encode([
    [
        
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/users/:user_id/resource_pools', [
  'body' => '[
  {}
]',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/users/:user_id/resource_pools');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/users/:user_id/resource_pools');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/users/:user_id/resource_pools' -Method PUT -Headers $headers -ContentType 'application/json' -Body '[
  {}
]'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/users/:user_id/resource_pools' -Method PUT -Headers $headers -ContentType 'application/json' -Body '[
  {}
]'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "[\n  {}\n]"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/users/:user_id/resource_pools", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/users/:user_id/resource_pools"

payload = [{}]
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/users/:user_id/resource_pools"

payload <- "[\n  {}\n]"

encode <- "json"

response <- VERB("PUT", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/users/:user_id/resource_pools")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)
request["content-type"] = 'application/json'
request.body = "[\n  {}\n]"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/users/:user_id/resource_pools') do |req|
  req.body = "[\n  {}\n]"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/users/:user_id/resource_pools";

    let payload = (json!({}));

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '[
  {}
]' |  \
  http PUT {{baseUrl}}/users/:user_id/resource_pools \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '[\n  {}\n]' \
  --output-document \
  - {{baseUrl}}/users/:user_id/resource_pools

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [[]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/users/:user_id/resource_pools")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/error");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/error")

require "http/client"

url = "{{baseUrl}}/error"

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}}/error"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/error");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/error"

	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/error HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/error")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/error"))
    .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}}/error")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/error")
  .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}}/error');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/error'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/error';
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}}/error',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/error")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/error',
  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}}/error'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/error');

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}}/error'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/error';
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}}/error"]
                                                       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}}/error" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/error",
  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}}/error');

echo $response->getBody();

setUrl('{{baseUrl}}/error');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/error');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/error' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/error' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/error")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/error"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/error"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/error")

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/error') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/error";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/error

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/error

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/error")! 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}}/version");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/version")

require "http/client"

url = "{{baseUrl}}/version"

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}}/version"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/version");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/version"

	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/version HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/version")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/version"))
    .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}}/version")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/version")
  .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}}/version');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/version'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/version';
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}}/version',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/version")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/version',
  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}}/version'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/version');

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}}/version'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/version';
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}}/version"]
                                                       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}}/version" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/version",
  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}}/version');

echo $response->getBody();

setUrl('{{baseUrl}}/version');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/version');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/version' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/version' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/version")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/version"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/version"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/version")

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/version') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/version";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/version

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/version

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/version")! 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()