CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bots/:name/versions");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/bots/:name/versions" {:content-type :json
                                                                :form-params {:checksum ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/bots/:name/versions"

	payload := strings.NewReader("{\n  \"checksum\": \"\"\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/bots/:name/versions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 20

{
  "checksum": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/bots/:name/versions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"checksum\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/bots/:name/versions")
  .header("content-type", "application/json")
  .body("{\n  \"checksum\": \"\"\n}")
  .asString();

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

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/bots/:name/versions',
  headers: {'content-type': 'application/json'},
  data: {checksum: ''}
};

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

const url = '{{baseUrl}}/bots/:name/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"checksum":""}'
};

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}}/bots/:name/versions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "checksum": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"checksum\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/bots/:name/versions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({checksum: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/bots/:name/versions',
  headers: {'content-type': 'application/json'},
  body: {checksum: ''},
  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}}/bots/:name/versions');

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

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

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}}/bots/:name/versions',
  headers: {'content-type': 'application/json'},
  data: {checksum: ''}
};

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

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

const url = '{{baseUrl}}/bots/:name/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"checksum":""}'
};

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 = @{ @"checksum": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

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

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

 "{{baseUrl}}/bots/:name/versions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'checksum' => ''
  ]),
  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}}/bots/:name/versions', [
  'body' => '{
  "checksum": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'checksum' => ''
]));
$request->setRequestUrl('{{baseUrl}}/bots/:name/versions');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/bots/:name/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "checksum": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/bots/:name/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "checksum": ""
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/bots/:name/versions", payload, headers)

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

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

import requests

url = "{{baseUrl}}/bots/:name/versions"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/bots/:name/versions"

payload <- "{\n  \"checksum\": \"\"\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}}/bots/:name/versions")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"checksum\": \"\"\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/bots/:name/versions') do |req|
  req.body = "{\n  \"checksum\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

    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 '{
  "checksum": ""
}' |  \
  http POST {{baseUrl}}/bots/:name/versions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "checksum": ""\n}' \
  --output-document \
  - {{baseUrl}}/bots/:name/versions

import Foundation

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

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/intents/:name/versions");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/intents/:name/versions" {:content-type :json
                                                                   :form-params {:checksum ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/intents/:name/versions"

	payload := strings.NewReader("{\n  \"checksum\": \"\"\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/intents/:name/versions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 20

{
  "checksum": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/intents/:name/versions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"checksum\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/intents/:name/versions")
  .header("content-type", "application/json")
  .body("{\n  \"checksum\": \"\"\n}")
  .asString();

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

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/intents/:name/versions',
  headers: {'content-type': 'application/json'},
  data: {checksum: ''}
};

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

const url = '{{baseUrl}}/intents/:name/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"checksum":""}'
};

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}}/intents/:name/versions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "checksum": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"checksum\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/intents/:name/versions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({checksum: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/intents/:name/versions',
  headers: {'content-type': 'application/json'},
  body: {checksum: ''},
  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}}/intents/:name/versions');

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

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

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}}/intents/:name/versions',
  headers: {'content-type': 'application/json'},
  data: {checksum: ''}
};

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

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

const url = '{{baseUrl}}/intents/:name/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"checksum":""}'
};

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 = @{ @"checksum": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

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

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

 "{{baseUrl}}/intents/:name/versions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'checksum' => ''
  ]),
  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}}/intents/:name/versions', [
  'body' => '{
  "checksum": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'checksum' => ''
]));
$request->setRequestUrl('{{baseUrl}}/intents/:name/versions');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/intents/:name/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "checksum": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/intents/:name/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "checksum": ""
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/intents/:name/versions", payload, headers)

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

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

import requests

url = "{{baseUrl}}/intents/:name/versions"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/intents/:name/versions"

payload <- "{\n  \"checksum\": \"\"\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}}/intents/:name/versions")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"checksum\": \"\"\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/intents/:name/versions') do |req|
  req.body = "{\n  \"checksum\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

    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 '{
  "checksum": ""
}' |  \
  http POST {{baseUrl}}/intents/:name/versions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "checksum": ""\n}' \
  --output-document \
  - {{baseUrl}}/intents/:name/versions

import Foundation

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

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/slottypes/:name/versions");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/slottypes/:name/versions" {:content-type :json
                                                                     :form-params {:checksum ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/slottypes/:name/versions"

	payload := strings.NewReader("{\n  \"checksum\": \"\"\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/slottypes/:name/versions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 20

{
  "checksum": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/slottypes/:name/versions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"checksum\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/slottypes/:name/versions")
  .header("content-type", "application/json")
  .body("{\n  \"checksum\": \"\"\n}")
  .asString();

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

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/slottypes/:name/versions',
  headers: {'content-type': 'application/json'},
  data: {checksum: ''}
};

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

const url = '{{baseUrl}}/slottypes/:name/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"checksum":""}'
};

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}}/slottypes/:name/versions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "checksum": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"checksum\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/slottypes/:name/versions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({checksum: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/slottypes/:name/versions',
  headers: {'content-type': 'application/json'},
  body: {checksum: ''},
  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}}/slottypes/:name/versions');

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

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

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}}/slottypes/:name/versions',
  headers: {'content-type': 'application/json'},
  data: {checksum: ''}
};

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

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

const url = '{{baseUrl}}/slottypes/:name/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"checksum":""}'
};

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 = @{ @"checksum": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

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

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

 "{{baseUrl}}/slottypes/:name/versions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'checksum' => ''
  ]),
  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}}/slottypes/:name/versions', [
  'body' => '{
  "checksum": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'checksum' => ''
]));
$request->setRequestUrl('{{baseUrl}}/slottypes/:name/versions');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/slottypes/:name/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "checksum": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/slottypes/:name/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "checksum": ""
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/slottypes/:name/versions", payload, headers)

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

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

import requests

url = "{{baseUrl}}/slottypes/:name/versions"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/slottypes/:name/versions"

payload <- "{\n  \"checksum\": \"\"\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}}/slottypes/:name/versions")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"checksum\": \"\"\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/slottypes/:name/versions') do |req|
  req.body = "{\n  \"checksum\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

    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 '{
  "checksum": ""
}' |  \
  http POST {{baseUrl}}/slottypes/:name/versions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "checksum": ""\n}' \
  --output-document \
  - {{baseUrl}}/slottypes/:name/versions

import Foundation

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

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

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

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

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

package main

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

func main() {

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

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

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

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

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

}

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

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

const data = null;

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

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

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

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

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

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

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

curl_close($curl);

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

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

response = requests.delete(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

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

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

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

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

    dbg!(results);
}

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

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

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/bots/:botName/aliases/:name")

require "http/client"

url = "{{baseUrl}}/bots/:botName/aliases/:name"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/bots/:botName/aliases/:name"

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

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

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

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

}

DELETE /baseUrl/bots/:botName/aliases/:name HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/bots/:botName/aliases/:name');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/bots/:botName/aliases/:name'
};

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

const url = '{{baseUrl}}/bots/:botName/aliases/:name';
const options = {method: 'DELETE'};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/bots/:botName/aliases/:name'
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/bots/:botName/aliases/:name'
};

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

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

const url = '{{baseUrl}}/bots/:botName/aliases/:name';
const options = {method: 'DELETE'};

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/bots/:botName/aliases/:name" in

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

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

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/bots/:botName/aliases/:name');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("DELETE", "/baseUrl/bots/:botName/aliases/:name")

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

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

import requests

url = "{{baseUrl}}/bots/:botName/aliases/:name"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bots/:botName/aliases/:name"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bots/:botName/aliases/:name")

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

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

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

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/bots/:botName/aliases/:name

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/bots/:botName/aliases/:name

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name")

require "http/client"

url = "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name"

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

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

var client = new RestClient("{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name"

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

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

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

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

}

DELETE /baseUrl/bots/:botName/aliases/:aliasName/channels/:name HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name'
};

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

const url = '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bots/:botName/aliases/:aliasName/channels/:name',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name'
};

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

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

const url = '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name';
const options = {method: 'DELETE'};

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name" in

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

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

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name');

echo $response->getBody();

setUrl('{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/bots/:botName/aliases/:aliasName/channels/:name")

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

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

import requests

url = "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/bots/:botName/aliases/:aliasName/channels/:name') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name";

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

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

    dbg!(results);
}

http DELETE {{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/bots/:name/versions/:version")

require "http/client"

url = "{{baseUrl}}/bots/:name/versions/:version"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/bots/:name/versions/:version"

	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/bots/:name/versions/:version HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/bots/:name/versions/:version'
};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/bots/:name/versions/: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: 'DELETE',
  url: '{{baseUrl}}/bots/:name/versions/:version'
};

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

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

const url = '{{baseUrl}}/bots/:name/versions/:version';
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}}/bots/:name/versions/:version"]
                                                       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}}/bots/:name/versions/:version" in

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

 "{{baseUrl}}/bots/:name/versions/:version",
  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}}/bots/:name/versions/:version');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("DELETE", "/baseUrl/bots/:name/versions/:version")

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

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

import requests

url = "{{baseUrl}}/bots/:name/versions/:version"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bots/:name/versions/:version"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bots/:name/versions/:version")

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/bots/:name/versions/:version') do |req|
end

puts response.status
puts response.body

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

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

    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}}/bots/:name/versions/:version

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/bots/:name/versions/:version

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

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

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

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

package main

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

func main() {

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

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

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

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

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

}

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

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

const data = null;

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

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

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

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

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

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

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

curl_close($curl);

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

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

response = requests.delete(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

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

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

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

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

    dbg!(results);
}

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

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

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/intents/:name/versions/:version")

require "http/client"

url = "{{baseUrl}}/intents/:name/versions/:version"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/intents/:name/versions/:version"

	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/intents/:name/versions/:version HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/intents/:name/versions/:version'
};

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/intents/:name/versions/: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: 'DELETE',
  url: '{{baseUrl}}/intents/:name/versions/:version'
};

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

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

const url = '{{baseUrl}}/intents/:name/versions/:version';
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}}/intents/:name/versions/:version"]
                                                       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}}/intents/:name/versions/:version" in

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

 "{{baseUrl}}/intents/:name/versions/:version",
  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}}/intents/:name/versions/:version');

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

conn.request("DELETE", "/baseUrl/intents/:name/versions/:version")

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

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

import requests

url = "{{baseUrl}}/intents/:name/versions/:version"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/intents/:name/versions/:version"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/intents/:name/versions/:version")

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/intents/:name/versions/:version') do |req|
end

puts response.status
puts response.body

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

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

    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}}/intents/:name/versions/:version

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/intents/:name/versions/:version

import Foundation

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

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

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

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

package main

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

func main() {

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

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

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

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

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

}

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

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

const data = null;

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

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

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

#import 

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

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

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

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

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

curl_close($curl);

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

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

response = requests.delete(url)

print(response.json())

library(httr)

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

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

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

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

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

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

    dbg!(results);
}

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

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

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/slottypes/:name/version/:version")

require "http/client"

url = "{{baseUrl}}/slottypes/:name/version/:version"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/slottypes/:name/version/:version"

	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/slottypes/:name/version/:version HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

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

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

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/slottypes/:name/version/: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: 'DELETE',
  url: '{{baseUrl}}/slottypes/:name/version/:version'
};

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

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

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

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

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

echo $response->getBody();

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

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

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

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

echo $response->getBody();

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

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

import http.client

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

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

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

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

import requests

url = "{{baseUrl}}/slottypes/:name/version/:version"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/slottypes/:name/version/:version"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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/slottypes/:name/version/:version') do |req|
end

puts response.status
puts response.body

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

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

    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}}/slottypes/:name/version/:version

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

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/slottypes/:name/version/:version")! 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}}/bots/:botName/utterances/:userId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/bots/:botName/utterances/:userId")

require "http/client"

url = "{{baseUrl}}/bots/:botName/utterances/:userId"

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

var client = new RestClient("{{baseUrl}}/bots/:botName/utterances/:userId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/bots/:botName/utterances/:userId"

	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/bots/:botName/utterances/:userId HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/bots/:botName/utterances/:userId'
};

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

const url = '{{baseUrl}}/bots/:botName/utterances/:userId';
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}}/bots/:botName/utterances/:userId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bots/:botName/utterances/:userId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bots/:botName/utterances/:userId',
  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}}/bots/:botName/utterances/:userId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/bots/:botName/utterances/:userId');

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}}/bots/:botName/utterances/:userId'
};

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

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

const url = '{{baseUrl}}/bots/:botName/utterances/:userId';
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}}/bots/:botName/utterances/:userId"]
                                                       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}}/bots/:botName/utterances/:userId" in

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

 "{{baseUrl}}/bots/:botName/utterances/:userId",
  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}}/bots/:botName/utterances/:userId');

echo $response->getBody();

setUrl('{{baseUrl}}/bots/:botName/utterances/:userId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/bots/:botName/utterances/:userId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bots/:botName/utterances/:userId' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bots/:botName/utterances/:userId' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/bots/:botName/utterances/:userId")

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

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

import requests

url = "{{baseUrl}}/bots/:botName/utterances/:userId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bots/:botName/utterances/:userId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bots/:botName/utterances/:userId")

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/bots/:botName/utterances/:userId') do |req|
end

puts response.status
puts response.body

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

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

    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}}/bots/:botName/utterances/:userId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/bots/:botName/utterances/:userId

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bots/:name/versions/:versionoralias");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/bots/:name/versions/:versionoralias")

require "http/client"

url = "{{baseUrl}}/bots/:name/versions/:versionoralias"

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

var client = new RestClient("{{baseUrl}}/bots/:name/versions/:versionoralias");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/bots/:name/versions/:versionoralias"

	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/bots/:name/versions/:versionoralias HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bots/:name/versions/:versionoralias'
};

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

const url = '{{baseUrl}}/bots/:name/versions/:versionoralias';
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}}/bots/:name/versions/:versionoralias',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bots/:name/versions/:versionoralias")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bots/:name/versions/:versionoralias');

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}}/bots/:name/versions/:versionoralias'
};

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

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

const url = '{{baseUrl}}/bots/:name/versions/:versionoralias';
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}}/bots/:name/versions/:versionoralias"]
                                                       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}}/bots/:name/versions/:versionoralias" in

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

 "{{baseUrl}}/bots/:name/versions/:versionoralias",
  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}}/bots/:name/versions/:versionoralias');

echo $response->getBody();

setUrl('{{baseUrl}}/bots/:name/versions/:versionoralias');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/bots/:name/versions/:versionoralias');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bots/:name/versions/:versionoralias' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bots/:name/versions/:versionoralias' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/bots/:name/versions/:versionoralias")

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

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

import requests

url = "{{baseUrl}}/bots/:name/versions/:versionoralias"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bots/:name/versions/:versionoralias"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bots/:name/versions/:versionoralias")

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/bots/:name/versions/:versionoralias') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/bots/:name/versions/:versionoralias

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bots/:name/versions/:versionoralias

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bots/:name/versions/:versionoralias")! 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}}/bots/:botName/aliases/:name");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/bots/:botName/aliases/:name")

require "http/client"

url = "{{baseUrl}}/bots/:botName/aliases/:name"

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

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

var client = new RestClient("{{baseUrl}}/bots/:botName/aliases/:name");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/bots/:botName/aliases/:name"

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

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

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

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

}

GET /baseUrl/bots/:botName/aliases/:name HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/bots/:botName/aliases/:name")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/bots/:botName/aliases/:name")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/bots/:botName/aliases/:name');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/bots/:botName/aliases/:name'};

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

const url = '{{baseUrl}}/bots/:botName/aliases/:name';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/bots/:botName/aliases/:name',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bots/:botName/aliases/:name")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bots/:botName/aliases/:name',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/bots/:botName/aliases/:name'};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bots/:botName/aliases/:name');

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

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

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

const options = {method: 'GET', url: '{{baseUrl}}/bots/:botName/aliases/:name'};

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

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

const url = '{{baseUrl}}/bots/:botName/aliases/:name';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/bots/:botName/aliases/:name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/bots/:botName/aliases/:name" in

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

 "{{baseUrl}}/bots/:botName/aliases/:name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/bots/:botName/aliases/:name');

echo $response->getBody();

setUrl('{{baseUrl}}/bots/:botName/aliases/:name');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/bots/:botName/aliases/:name');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bots/:botName/aliases/:name' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bots/:botName/aliases/:name' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/bots/:botName/aliases/:name")

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

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

import requests

url = "{{baseUrl}}/bots/:botName/aliases/:name"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bots/:botName/aliases/:name"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bots/:botName/aliases/:name")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/bots/:botName/aliases/:name') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/bots/:botName/aliases/:name

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bots/:botName/aliases/:name

import Foundation

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bots/:botName/aliases/");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/bots/:botName/aliases/")

require "http/client"

url = "{{baseUrl}}/bots/:botName/aliases/"

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

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

package main

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

func main() {

	url := "{{baseUrl}}/bots/:botName/aliases/"

	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/bots/:botName/aliases/ HTTP/1.1
Host: example.com

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

client.close();

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/bots/:botName/aliases/'};

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

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

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bots/:botName/aliases/")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bots/:botName/aliases/');

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}}/bots/:botName/aliases/'};

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

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

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

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

 "{{baseUrl}}/bots/:botName/aliases/",
  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}}/bots/:botName/aliases/');

echo $response->getBody();

setUrl('{{baseUrl}}/bots/:botName/aliases/');
$request->setMethod(HTTP_METH_GET);

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

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

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bots/:botName/aliases/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bots/:botName/aliases/' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/bots/:botName/aliases/")

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

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

import requests

url = "{{baseUrl}}/bots/:botName/aliases/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bots/:botName/aliases/"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bots/:botName/aliases/")

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/bots/:botName/aliases/') do |req|
end

puts response.status
puts response.body

use reqwest;

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

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

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

    dbg!(results);
}

http GET {{baseUrl}}/bots/:botName/aliases/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bots/:botName/aliases/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bots/:botName/aliases/")! 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}}/bots/:botName/aliases/:aliasName/channels/:name");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name")

require "http/client"

url = "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name"

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

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

var client = new RestClient("{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name"

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

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

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

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

}

GET /baseUrl/bots/:botName/aliases/:aliasName/channels/:name HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name'
};

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

const url = '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bots/:botName/aliases/:aliasName/channels/:name',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name'
};

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

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

const url = '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name" in

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

 "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name');

echo $response->getBody();

setUrl('{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/bots/:botName/aliases/:aliasName/channels/:name")

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

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

import requests

url = "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/bots/:botName/aliases/:aliasName/channels/:name') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/:name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/")

require "http/client"

url = "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/"

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

var client = new RestClient("{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/"

	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/bots/:botName/aliases/:aliasName/channels/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/"))
    .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}}/bots/:botName/aliases/:aliasName/channels/")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/")
  .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}}/bots/:botName/aliases/:aliasName/channels/');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/'
};

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

const url = '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/';
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}}/bots/:botName/aliases/:aliasName/channels/',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/');

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}}/bots/:botName/aliases/:aliasName/channels/'
};

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

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

const url = '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/';
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}}/bots/:botName/aliases/:aliasName/channels/"]
                                                       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}}/bots/:botName/aliases/:aliasName/channels/" in

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

 "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/",
  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}}/bots/:botName/aliases/:aliasName/channels/');

echo $response->getBody();

setUrl('{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/bots/:botName/aliases/:aliasName/channels/")

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

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

import requests

url = "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/")

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/bots/:botName/aliases/:aliasName/channels/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/bots/:botName/aliases/:aliasName/channels/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bots/:botName/aliases/:aliasName/channels/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bots/:botName/aliases/:aliasName/channels/")! 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}}/bots/:name/versions/");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/bots/:name/versions/")

require "http/client"

url = "{{baseUrl}}/bots/:name/versions/"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/bots/:name/versions/"

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

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

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

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

}

GET /baseUrl/bots/:name/versions/ HTTP/1.1
Host: example.com

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

client.close();

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

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/bots/:name/versions/")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/bots/:name/versions/")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/bots/:name/versions/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/bots/:name/versions/'};

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

const url = '{{baseUrl}}/bots/:name/versions/';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/bots/:name/versions/',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bots/:name/versions/")
  .get()
  .build()

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

const http = require('https');

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

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

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

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

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/bots/:name/versions/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bots/:name/versions/');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/bots/:name/versions/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bots/:name/versions/';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/bots/:name/versions/"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/bots/:name/versions/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bots/:name/versions/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/bots/:name/versions/');

echo $response->getBody();

setUrl('{{baseUrl}}/bots/:name/versions/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bots/:name/versions/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bots/:name/versions/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bots/:name/versions/' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bots/:name/versions/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bots/:name/versions/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bots/:name/versions/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bots/:name/versions/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/bots/:name/versions/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bots/:name/versions/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/bots/:name/versions/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bots/:name/versions/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bots/:name/versions/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bots/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bots/")

require "http/client"

url = "{{baseUrl}}/bots/"

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}}/bots/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bots/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bots/"

	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/bots/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bots/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bots/"))
    .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}}/bots/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bots/")
  .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}}/bots/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/bots/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bots/';
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}}/bots/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bots/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bots/',
  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}}/bots/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bots/');

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}}/bots/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bots/';
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}}/bots/"]
                                                       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}}/bots/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bots/",
  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}}/bots/');

echo $response->getBody();

setUrl('{{baseUrl}}/bots/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bots/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bots/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bots/' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bots/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bots/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bots/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bots/")

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/bots/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bots/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/bots/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/bots/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bots/")! 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}}/builtins/intents/:signature");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/builtins/intents/:signature")

require "http/client"

url = "{{baseUrl}}/builtins/intents/:signature"

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}}/builtins/intents/:signature"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/builtins/intents/:signature");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/builtins/intents/:signature"

	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/builtins/intents/:signature HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/builtins/intents/:signature")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/builtins/intents/:signature"))
    .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}}/builtins/intents/:signature")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/builtins/intents/:signature")
  .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}}/builtins/intents/:signature');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/builtins/intents/:signature'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/builtins/intents/:signature';
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}}/builtins/intents/:signature',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/builtins/intents/:signature")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/builtins/intents/:signature',
  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}}/builtins/intents/:signature'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/builtins/intents/:signature');

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}}/builtins/intents/:signature'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/builtins/intents/:signature';
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}}/builtins/intents/:signature"]
                                                       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}}/builtins/intents/:signature" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/builtins/intents/:signature",
  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}}/builtins/intents/:signature');

echo $response->getBody();

setUrl('{{baseUrl}}/builtins/intents/:signature');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/builtins/intents/:signature');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/builtins/intents/:signature' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/builtins/intents/:signature' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/builtins/intents/:signature")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/builtins/intents/:signature"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/builtins/intents/:signature"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/builtins/intents/:signature")

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/builtins/intents/:signature') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/builtins/intents/:signature";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/builtins/intents/:signature

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/builtins/intents/:signature

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/builtins/intents/:signature")! 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}}/builtins/intents/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/builtins/intents/")

require "http/client"

url = "{{baseUrl}}/builtins/intents/"

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}}/builtins/intents/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/builtins/intents/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/builtins/intents/"

	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/builtins/intents/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/builtins/intents/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/builtins/intents/"))
    .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}}/builtins/intents/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/builtins/intents/")
  .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}}/builtins/intents/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/builtins/intents/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/builtins/intents/';
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}}/builtins/intents/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/builtins/intents/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/builtins/intents/',
  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}}/builtins/intents/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/builtins/intents/');

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}}/builtins/intents/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/builtins/intents/';
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}}/builtins/intents/"]
                                                       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}}/builtins/intents/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/builtins/intents/",
  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}}/builtins/intents/');

echo $response->getBody();

setUrl('{{baseUrl}}/builtins/intents/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/builtins/intents/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/builtins/intents/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/builtins/intents/' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/builtins/intents/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/builtins/intents/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/builtins/intents/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/builtins/intents/")

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/builtins/intents/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/builtins/intents/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/builtins/intents/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/builtins/intents/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/builtins/intents/")! 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}}/builtins/slottypes/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/builtins/slottypes/")

require "http/client"

url = "{{baseUrl}}/builtins/slottypes/"

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}}/builtins/slottypes/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/builtins/slottypes/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/builtins/slottypes/"

	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/builtins/slottypes/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/builtins/slottypes/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/builtins/slottypes/"))
    .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}}/builtins/slottypes/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/builtins/slottypes/")
  .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}}/builtins/slottypes/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/builtins/slottypes/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/builtins/slottypes/';
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}}/builtins/slottypes/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/builtins/slottypes/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/builtins/slottypes/',
  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}}/builtins/slottypes/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/builtins/slottypes/');

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}}/builtins/slottypes/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/builtins/slottypes/';
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}}/builtins/slottypes/"]
                                                       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}}/builtins/slottypes/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/builtins/slottypes/",
  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}}/builtins/slottypes/');

echo $response->getBody();

setUrl('{{baseUrl}}/builtins/slottypes/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/builtins/slottypes/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/builtins/slottypes/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/builtins/slottypes/' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/builtins/slottypes/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/builtins/slottypes/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/builtins/slottypes/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/builtins/slottypes/")

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/builtins/slottypes/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/builtins/slottypes/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/builtins/slottypes/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/builtins/slottypes/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/builtins/slottypes/")! 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}}/exports/?name=&version=&resourceType=&exportType=#name&version&resourceType&exportType");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/exports/#name&version&resourceType&exportType" {:query-params {:name ""
                                                                                                        :version ""
                                                                                                        :resourceType ""
                                                                                                        :exportType ""}})

require "http/client"

url = "{{baseUrl}}/exports/?name=&version=&resourceType=&exportType=#name&version&resourceType&exportType"

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}}/exports/?name=&version=&resourceType=&exportType=#name&version&resourceType&exportType"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/exports/?name=&version=&resourceType=&exportType=#name&version&resourceType&exportType");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/exports/?name=&version=&resourceType=&exportType=#name&version&resourceType&exportType"

	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/exports/?name=&version=&resourceType=&exportType= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/exports/?name=&version=&resourceType=&exportType=#name&version&resourceType&exportType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/exports/?name=&version=&resourceType=&exportType=#name&version&resourceType&exportType"))
    .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}}/exports/?name=&version=&resourceType=&exportType=#name&version&resourceType&exportType")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/exports/?name=&version=&resourceType=&exportType=#name&version&resourceType&exportType")
  .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}}/exports/?name=&version=&resourceType=&exportType=#name&version&resourceType&exportType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/exports/#name&version&resourceType&exportType',
  params: {name: '', version: '', resourceType: '', exportType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/exports/?name=&version=&resourceType=&exportType=#name&version&resourceType&exportType';
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}}/exports/?name=&version=&resourceType=&exportType=#name&version&resourceType&exportType',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/exports/?name=&version=&resourceType=&exportType=#name&version&resourceType&exportType")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/exports/?name=&version=&resourceType=&exportType=',
  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}}/exports/#name&version&resourceType&exportType',
  qs: {name: '', version: '', resourceType: '', exportType: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/exports/#name&version&resourceType&exportType');

req.query({
  name: '',
  version: '',
  resourceType: '',
  exportType: ''
});

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}}/exports/#name&version&resourceType&exportType',
  params: {name: '', version: '', resourceType: '', exportType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/exports/?name=&version=&resourceType=&exportType=#name&version&resourceType&exportType';
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}}/exports/?name=&version=&resourceType=&exportType=#name&version&resourceType&exportType"]
                                                       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}}/exports/?name=&version=&resourceType=&exportType=#name&version&resourceType&exportType" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/exports/?name=&version=&resourceType=&exportType=#name&version&resourceType&exportType",
  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}}/exports/?name=&version=&resourceType=&exportType=#name&version&resourceType&exportType');

echo $response->getBody();

setUrl('{{baseUrl}}/exports/#name&version&resourceType&exportType');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'name' => '',
  'version' => '',
  'resourceType' => '',
  'exportType' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/exports/#name&version&resourceType&exportType');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'name' => '',
  'version' => '',
  'resourceType' => '',
  'exportType' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/exports/?name=&version=&resourceType=&exportType=#name&version&resourceType&exportType' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/exports/?name=&version=&resourceType=&exportType=#name&version&resourceType&exportType' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/exports/?name=&version=&resourceType=&exportType=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/exports/#name&version&resourceType&exportType"

querystring = {"name":"","version":"","resourceType":"","exportType":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/exports/#name&version&resourceType&exportType"

queryString <- list(
  name = "",
  version = "",
  resourceType = "",
  exportType = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/exports/?name=&version=&resourceType=&exportType=#name&version&resourceType&exportType")

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/exports/') do |req|
  req.params['name'] = ''
  req.params['version'] = ''
  req.params['resourceType'] = ''
  req.params['exportType'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/exports/#name&version&resourceType&exportType";

    let querystring = [
        ("name", ""),
        ("version", ""),
        ("resourceType", ""),
        ("exportType", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET '{{baseUrl}}/exports/?name=&version=&resourceType=&exportType=#name&version&resourceType&exportType'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/exports/?name=&version=&resourceType=&exportType=#name&version&resourceType&exportType'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/exports/?name=&version=&resourceType=&exportType=#name&version&resourceType&exportType")! 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}}/imports/:importId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/imports/:importId")

require "http/client"

url = "{{baseUrl}}/imports/:importId"

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}}/imports/:importId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/imports/:importId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/imports/:importId"

	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/imports/:importId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/imports/:importId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/imports/:importId"))
    .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}}/imports/:importId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/imports/:importId")
  .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}}/imports/:importId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/imports/:importId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/imports/:importId';
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}}/imports/:importId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/imports/:importId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/imports/:importId',
  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}}/imports/:importId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/imports/:importId');

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}}/imports/:importId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/imports/:importId';
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}}/imports/:importId"]
                                                       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}}/imports/:importId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/imports/:importId",
  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}}/imports/:importId');

echo $response->getBody();

setUrl('{{baseUrl}}/imports/:importId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/imports/:importId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/imports/:importId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/imports/:importId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/imports/:importId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/imports/:importId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/imports/:importId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/imports/:importId")

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/imports/:importId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/imports/:importId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/imports/:importId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/imports/:importId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/imports/:importId")! 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}}/intents/:name/versions/:version");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/intents/:name/versions/:version")

require "http/client"

url = "{{baseUrl}}/intents/:name/versions/: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}}/intents/:name/versions/:version"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/intents/:name/versions/:version");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/intents/:name/versions/: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/intents/:name/versions/:version HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/intents/:name/versions/:version")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/intents/:name/versions/: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}}/intents/:name/versions/:version")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/intents/:name/versions/: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}}/intents/:name/versions/:version');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/intents/:name/versions/:version'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/intents/:name/versions/: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}}/intents/:name/versions/:version',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/intents/:name/versions/:version")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/intents/:name/versions/: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}}/intents/:name/versions/: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}}/intents/:name/versions/: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}}/intents/:name/versions/:version'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/intents/:name/versions/: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}}/intents/:name/versions/: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}}/intents/:name/versions/:version" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/intents/:name/versions/: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}}/intents/:name/versions/:version');

echo $response->getBody();

setUrl('{{baseUrl}}/intents/:name/versions/:version');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/intents/:name/versions/:version');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/intents/:name/versions/:version' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/intents/:name/versions/:version' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/intents/:name/versions/:version")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/intents/:name/versions/:version"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/intents/:name/versions/:version"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/intents/:name/versions/: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/intents/:name/versions/:version') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/intents/:name/versions/: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}}/intents/:name/versions/:version

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/intents/:name/versions/:version

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/intents/:name/versions/: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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/intents/:name/versions/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/intents/:name/versions/")

require "http/client"

url = "{{baseUrl}}/intents/:name/versions/"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/intents/:name/versions/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/intents/:name/versions/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/intents/:name/versions/"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/intents/:name/versions/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/intents/:name/versions/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/intents/:name/versions/"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/intents/:name/versions/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/intents/:name/versions/")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/intents/:name/versions/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/intents/:name/versions/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/intents/:name/versions/';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/intents/:name/versions/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/intents/:name/versions/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/intents/:name/versions/',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/intents/:name/versions/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/intents/:name/versions/');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/intents/:name/versions/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/intents/:name/versions/';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/intents/:name/versions/"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/intents/:name/versions/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/intents/:name/versions/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/intents/:name/versions/');

echo $response->getBody();

setUrl('{{baseUrl}}/intents/:name/versions/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/intents/:name/versions/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/intents/:name/versions/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/intents/:name/versions/' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/intents/:name/versions/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/intents/:name/versions/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/intents/:name/versions/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/intents/:name/versions/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/intents/:name/versions/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/intents/:name/versions/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/intents/:name/versions/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/intents/:name/versions/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/intents/:name/versions/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/intents/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/intents/")

require "http/client"

url = "{{baseUrl}}/intents/"

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}}/intents/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/intents/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/intents/"

	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/intents/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/intents/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/intents/"))
    .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}}/intents/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/intents/")
  .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}}/intents/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/intents/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/intents/';
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}}/intents/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/intents/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/intents/',
  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}}/intents/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/intents/');

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}}/intents/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/intents/';
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}}/intents/"]
                                                       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}}/intents/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/intents/",
  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}}/intents/');

echo $response->getBody();

setUrl('{{baseUrl}}/intents/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/intents/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/intents/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/intents/' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/intents/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/intents/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/intents/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/intents/")

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/intents/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/intents/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/intents/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/intents/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/intents/")! 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}}/migrations/:migrationId");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/migrations/:migrationId")

require "http/client"

url = "{{baseUrl}}/migrations/:migrationId"

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}}/migrations/:migrationId"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/migrations/:migrationId");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/migrations/:migrationId"

	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/migrations/:migrationId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/migrations/:migrationId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/migrations/:migrationId"))
    .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}}/migrations/:migrationId")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/migrations/:migrationId")
  .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}}/migrations/:migrationId');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/migrations/:migrationId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/migrations/:migrationId';
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}}/migrations/:migrationId',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/migrations/:migrationId")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/migrations/:migrationId',
  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}}/migrations/:migrationId'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/migrations/:migrationId');

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}}/migrations/:migrationId'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/migrations/:migrationId';
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}}/migrations/:migrationId"]
                                                       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}}/migrations/:migrationId" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/migrations/:migrationId",
  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}}/migrations/:migrationId');

echo $response->getBody();

setUrl('{{baseUrl}}/migrations/:migrationId');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/migrations/:migrationId');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/migrations/:migrationId' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/migrations/:migrationId' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/migrations/:migrationId")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/migrations/:migrationId"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/migrations/:migrationId"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/migrations/:migrationId")

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/migrations/:migrationId') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/migrations/:migrationId";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/migrations/:migrationId

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/migrations/:migrationId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/migrations/:migrationId")! 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}}/migrations");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/migrations")

require "http/client"

url = "{{baseUrl}}/migrations"

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}}/migrations"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/migrations");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/migrations"

	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/migrations HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/migrations")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/migrations"))
    .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}}/migrations")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/migrations")
  .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}}/migrations');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/migrations'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/migrations';
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}}/migrations',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/migrations")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/migrations',
  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}}/migrations'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/migrations');

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}}/migrations'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/migrations';
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}}/migrations"]
                                                       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}}/migrations" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/migrations",
  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}}/migrations');

echo $response->getBody();

setUrl('{{baseUrl}}/migrations');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/migrations');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/migrations' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/migrations' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/migrations")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/migrations"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/migrations"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/migrations")

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/migrations') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/migrations";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/migrations

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/migrations

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/migrations")! 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}}/slottypes/:name/versions/:version");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/slottypes/:name/versions/:version")

require "http/client"

url = "{{baseUrl}}/slottypes/:name/versions/: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}}/slottypes/:name/versions/:version"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/slottypes/:name/versions/:version");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/slottypes/:name/versions/: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/slottypes/:name/versions/:version HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/slottypes/:name/versions/:version")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/slottypes/:name/versions/: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}}/slottypes/:name/versions/:version")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/slottypes/:name/versions/: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}}/slottypes/:name/versions/:version');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/slottypes/:name/versions/:version'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/slottypes/:name/versions/: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}}/slottypes/:name/versions/:version',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/slottypes/:name/versions/:version")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/slottypes/:name/versions/: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}}/slottypes/:name/versions/: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}}/slottypes/:name/versions/: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}}/slottypes/:name/versions/:version'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/slottypes/:name/versions/: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}}/slottypes/:name/versions/: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}}/slottypes/:name/versions/:version" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/slottypes/:name/versions/: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}}/slottypes/:name/versions/:version');

echo $response->getBody();

setUrl('{{baseUrl}}/slottypes/:name/versions/:version');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/slottypes/:name/versions/:version');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/slottypes/:name/versions/:version' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/slottypes/:name/versions/:version' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/slottypes/:name/versions/:version")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/slottypes/:name/versions/:version"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/slottypes/:name/versions/:version"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/slottypes/:name/versions/: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/slottypes/:name/versions/:version') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/slottypes/:name/versions/: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}}/slottypes/:name/versions/:version

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/slottypes/:name/versions/:version

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/slottypes/:name/versions/: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()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/slottypes/:name/versions/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/slottypes/:name/versions/")

require "http/client"

url = "{{baseUrl}}/slottypes/:name/versions/"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/slottypes/:name/versions/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/slottypes/:name/versions/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/slottypes/:name/versions/"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/slottypes/:name/versions/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/slottypes/:name/versions/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/slottypes/:name/versions/"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/slottypes/:name/versions/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/slottypes/:name/versions/")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/slottypes/:name/versions/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/slottypes/:name/versions/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/slottypes/:name/versions/';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/slottypes/:name/versions/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/slottypes/:name/versions/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/slottypes/:name/versions/',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/slottypes/:name/versions/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/slottypes/:name/versions/');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/slottypes/:name/versions/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/slottypes/:name/versions/';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/slottypes/:name/versions/"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/slottypes/:name/versions/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/slottypes/:name/versions/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/slottypes/:name/versions/');

echo $response->getBody();

setUrl('{{baseUrl}}/slottypes/:name/versions/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/slottypes/:name/versions/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/slottypes/:name/versions/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/slottypes/:name/versions/' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/slottypes/:name/versions/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/slottypes/:name/versions/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/slottypes/:name/versions/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/slottypes/:name/versions/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/slottypes/:name/versions/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/slottypes/:name/versions/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/slottypes/:name/versions/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/slottypes/:name/versions/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/slottypes/:name/versions/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/slottypes/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/slottypes/")

require "http/client"

url = "{{baseUrl}}/slottypes/"

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}}/slottypes/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/slottypes/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/slottypes/"

	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/slottypes/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/slottypes/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/slottypes/"))
    .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}}/slottypes/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/slottypes/")
  .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}}/slottypes/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/slottypes/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/slottypes/';
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}}/slottypes/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/slottypes/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/slottypes/',
  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}}/slottypes/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/slottypes/');

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}}/slottypes/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/slottypes/';
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}}/slottypes/"]
                                                       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}}/slottypes/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/slottypes/",
  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}}/slottypes/');

echo $response->getBody();

setUrl('{{baseUrl}}/slottypes/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/slottypes/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/slottypes/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/slottypes/' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/slottypes/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/slottypes/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/slottypes/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/slottypes/")

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/slottypes/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/slottypes/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/slottypes/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/slottypes/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/slottypes/")! 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}}/bots/:botname/utterances?bot_versions=&status_type=&view=#view=aggregation&bot_versions&status_type");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/bots/:botname/utterances#view=aggregation&bot_versions&status_type" {:query-params {:bot_versions ""
                                                                                                                             :status_type ""
                                                                                                                             :view ""}})

require "http/client"

url = "{{baseUrl}}/bots/:botname/utterances?bot_versions=&status_type=&view=#view=aggregation&bot_versions&status_type"

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}}/bots/:botname/utterances?bot_versions=&status_type=&view=#view=aggregation&bot_versions&status_type"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bots/:botname/utterances?bot_versions=&status_type=&view=#view=aggregation&bot_versions&status_type");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bots/:botname/utterances?bot_versions=&status_type=&view=#view=aggregation&bot_versions&status_type"

	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/bots/:botname/utterances?bot_versions=&status_type=&view= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/bots/:botname/utterances?bot_versions=&status_type=&view=#view=aggregation&bot_versions&status_type")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bots/:botname/utterances?bot_versions=&status_type=&view=#view=aggregation&bot_versions&status_type"))
    .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}}/bots/:botname/utterances?bot_versions=&status_type=&view=#view=aggregation&bot_versions&status_type")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/bots/:botname/utterances?bot_versions=&status_type=&view=#view=aggregation&bot_versions&status_type")
  .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}}/bots/:botname/utterances?bot_versions=&status_type=&view=#view=aggregation&bot_versions&status_type');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/bots/:botname/utterances#view=aggregation&bot_versions&status_type',
  params: {bot_versions: '', status_type: '', view: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bots/:botname/utterances?bot_versions=&status_type=&view=#view=aggregation&bot_versions&status_type';
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}}/bots/:botname/utterances?bot_versions=&status_type=&view=#view=aggregation&bot_versions&status_type',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/bots/:botname/utterances?bot_versions=&status_type=&view=#view=aggregation&bot_versions&status_type")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/bots/:botname/utterances?bot_versions=&status_type=&view=',
  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}}/bots/:botname/utterances#view=aggregation&bot_versions&status_type',
  qs: {bot_versions: '', status_type: '', view: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/bots/:botname/utterances#view=aggregation&bot_versions&status_type');

req.query({
  bot_versions: '',
  status_type: '',
  view: ''
});

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}}/bots/:botname/utterances#view=aggregation&bot_versions&status_type',
  params: {bot_versions: '', status_type: '', view: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bots/:botname/utterances?bot_versions=&status_type=&view=#view=aggregation&bot_versions&status_type';
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}}/bots/:botname/utterances?bot_versions=&status_type=&view=#view=aggregation&bot_versions&status_type"]
                                                       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}}/bots/:botname/utterances?bot_versions=&status_type=&view=#view=aggregation&bot_versions&status_type" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bots/:botname/utterances?bot_versions=&status_type=&view=#view=aggregation&bot_versions&status_type",
  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}}/bots/:botname/utterances?bot_versions=&status_type=&view=#view=aggregation&bot_versions&status_type');

echo $response->getBody();

setUrl('{{baseUrl}}/bots/:botname/utterances#view=aggregation&bot_versions&status_type');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'bot_versions' => '',
  'status_type' => '',
  'view' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/bots/:botname/utterances#view=aggregation&bot_versions&status_type');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'bot_versions' => '',
  'status_type' => '',
  'view' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/bots/:botname/utterances?bot_versions=&status_type=&view=#view=aggregation&bot_versions&status_type' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/bots/:botname/utterances?bot_versions=&status_type=&view=#view=aggregation&bot_versions&status_type' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/bots/:botname/utterances?bot_versions=&status_type=&view=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bots/:botname/utterances#view=aggregation&bot_versions&status_type"

querystring = {"bot_versions":"","status_type":"","view":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bots/:botname/utterances#view=aggregation&bot_versions&status_type"

queryString <- list(
  bot_versions = "",
  status_type = "",
  view = ""
)

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/bots/:botname/utterances?bot_versions=&status_type=&view=#view=aggregation&bot_versions&status_type")

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/bots/:botname/utterances') do |req|
  req.params['bot_versions'] = ''
  req.params['status_type'] = ''
  req.params['view'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/bots/:botname/utterances#view=aggregation&bot_versions&status_type";

    let querystring = [
        ("bot_versions", ""),
        ("status_type", ""),
        ("view", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET '{{baseUrl}}/bots/:botname/utterances?bot_versions=&status_type=&view=#view=aggregation&bot_versions&status_type'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/bots/:botname/utterances?bot_versions=&status_type=&view=#view=aggregation&bot_versions&status_type'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bots/:botname/utterances?bot_versions=&status_type=&view=#view=aggregation&bot_versions&status_type")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tags/:resourceArn");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/tags/:resourceArn")

require "http/client"

url = "{{baseUrl}}/tags/:resourceArn"

response = HTTP::Client.get url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/tags/:resourceArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tags/:resourceArn");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tags/:resourceArn"

	req, _ := http.NewRequest("GET", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

GET /baseUrl/tags/:resourceArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/tags/:resourceArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tags/:resourceArn"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/tags/:resourceArn")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('GET', '{{baseUrl}}/tags/:resourceArn');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/tags/:resourceArn'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tags/:resourceArn';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/tags/:resourceArn',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tags/:resourceArn',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {method: 'GET', url: '{{baseUrl}}/tags/:resourceArn'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/tags/:resourceArn');

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {method: 'GET', url: '{{baseUrl}}/tags/:resourceArn'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tags/:resourceArn';
const options = {method: 'GET'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tags/:resourceArn"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/tags/:resourceArn" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tags/:resourceArn",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/tags/:resourceArn');

echo $response->getBody();

setUrl('{{baseUrl}}/tags/:resourceArn');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tags/:resourceArn');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/tags/:resourceArn' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/tags/:resourceArn' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/tags/:resourceArn")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tags/:resourceArn"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags/:resourceArn"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tags/:resourceArn")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/tags/:resourceArn') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tags/:resourceArn";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/tags/:resourceArn

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/tags/:resourceArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tags/:resourceArn")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/bots/:name/versions/$LATEST");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"description\": \"\",\n  \"intents\": [\n    {\n      \"intentName\": \"\",\n      \"intentVersion\": \"\"\n    }\n  ],\n  \"enableModelImprovements\": false,\n  \"nluIntentConfidenceThreshold\": \"\",\n  \"clarificationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"abortStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"idleSessionTTLInSeconds\": 0,\n  \"voiceId\": \"\",\n  \"checksum\": \"\",\n  \"processBehavior\": \"\",\n  \"locale\": \"\",\n  \"childDirected\": false,\n  \"detectSentiment\": false,\n  \"createVersion\": false,\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/bots/:name/versions/$LATEST" {:content-type :json
                                                                       :form-params {:description ""
                                                                                     :intents [{:intentName ""
                                                                                                :intentVersion ""}]
                                                                                     :enableModelImprovements false
                                                                                     :nluIntentConfidenceThreshold ""
                                                                                     :clarificationPrompt {:messages ""
                                                                                                           :maxAttempts ""
                                                                                                           :responseCard ""}
                                                                                     :abortStatement {:messages ""
                                                                                                      :responseCard ""}
                                                                                     :idleSessionTTLInSeconds 0
                                                                                     :voiceId ""
                                                                                     :checksum ""
                                                                                     :processBehavior ""
                                                                                     :locale ""
                                                                                     :childDirected false
                                                                                     :detectSentiment false
                                                                                     :createVersion false
                                                                                     :tags [{:key ""
                                                                                             :value ""}]}})

require "http/client"

url = "{{baseUrl}}/bots/:name/versions/$LATEST"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"description\": \"\",\n  \"intents\": [\n    {\n      \"intentName\": \"\",\n      \"intentVersion\": \"\"\n    }\n  ],\n  \"enableModelImprovements\": false,\n  \"nluIntentConfidenceThreshold\": \"\",\n  \"clarificationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"abortStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"idleSessionTTLInSeconds\": 0,\n  \"voiceId\": \"\",\n  \"checksum\": \"\",\n  \"processBehavior\": \"\",\n  \"locale\": \"\",\n  \"childDirected\": false,\n  \"detectSentiment\": false,\n  \"createVersion\": false,\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\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}}/bots/:name/versions/$LATEST"),
    Content = new StringContent("{\n  \"description\": \"\",\n  \"intents\": [\n    {\n      \"intentName\": \"\",\n      \"intentVersion\": \"\"\n    }\n  ],\n  \"enableModelImprovements\": false,\n  \"nluIntentConfidenceThreshold\": \"\",\n  \"clarificationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"abortStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"idleSessionTTLInSeconds\": 0,\n  \"voiceId\": \"\",\n  \"checksum\": \"\",\n  \"processBehavior\": \"\",\n  \"locale\": \"\",\n  \"childDirected\": false,\n  \"detectSentiment\": false,\n  \"createVersion\": false,\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bots/:name/versions/$LATEST");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"description\": \"\",\n  \"intents\": [\n    {\n      \"intentName\": \"\",\n      \"intentVersion\": \"\"\n    }\n  ],\n  \"enableModelImprovements\": false,\n  \"nluIntentConfidenceThreshold\": \"\",\n  \"clarificationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"abortStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"idleSessionTTLInSeconds\": 0,\n  \"voiceId\": \"\",\n  \"checksum\": \"\",\n  \"processBehavior\": \"\",\n  \"locale\": \"\",\n  \"childDirected\": false,\n  \"detectSentiment\": false,\n  \"createVersion\": false,\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bots/:name/versions/$LATEST"

	payload := strings.NewReader("{\n  \"description\": \"\",\n  \"intents\": [\n    {\n      \"intentName\": \"\",\n      \"intentVersion\": \"\"\n    }\n  ],\n  \"enableModelImprovements\": false,\n  \"nluIntentConfidenceThreshold\": \"\",\n  \"clarificationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"abortStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"idleSessionTTLInSeconds\": 0,\n  \"voiceId\": \"\",\n  \"checksum\": \"\",\n  \"processBehavior\": \"\",\n  \"locale\": \"\",\n  \"childDirected\": false,\n  \"detectSentiment\": false,\n  \"createVersion\": false,\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\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/bots/:name/versions/$LATEST HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 599

{
  "description": "",
  "intents": [
    {
      "intentName": "",
      "intentVersion": ""
    }
  ],
  "enableModelImprovements": false,
  "nluIntentConfidenceThreshold": "",
  "clarificationPrompt": {
    "messages": "",
    "maxAttempts": "",
    "responseCard": ""
  },
  "abortStatement": {
    "messages": "",
    "responseCard": ""
  },
  "idleSessionTTLInSeconds": 0,
  "voiceId": "",
  "checksum": "",
  "processBehavior": "",
  "locale": "",
  "childDirected": false,
  "detectSentiment": false,
  "createVersion": false,
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/bots/:name/versions/$LATEST")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"description\": \"\",\n  \"intents\": [\n    {\n      \"intentName\": \"\",\n      \"intentVersion\": \"\"\n    }\n  ],\n  \"enableModelImprovements\": false,\n  \"nluIntentConfidenceThreshold\": \"\",\n  \"clarificationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"abortStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"idleSessionTTLInSeconds\": 0,\n  \"voiceId\": \"\",\n  \"checksum\": \"\",\n  \"processBehavior\": \"\",\n  \"locale\": \"\",\n  \"childDirected\": false,\n  \"detectSentiment\": false,\n  \"createVersion\": false,\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bots/:name/versions/$LATEST"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"description\": \"\",\n  \"intents\": [\n    {\n      \"intentName\": \"\",\n      \"intentVersion\": \"\"\n    }\n  ],\n  \"enableModelImprovements\": false,\n  \"nluIntentConfidenceThreshold\": \"\",\n  \"clarificationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"abortStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"idleSessionTTLInSeconds\": 0,\n  \"voiceId\": \"\",\n  \"checksum\": \"\",\n  \"processBehavior\": \"\",\n  \"locale\": \"\",\n  \"childDirected\": false,\n  \"detectSentiment\": false,\n  \"createVersion\": false,\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"intents\": [\n    {\n      \"intentName\": \"\",\n      \"intentVersion\": \"\"\n    }\n  ],\n  \"enableModelImprovements\": false,\n  \"nluIntentConfidenceThreshold\": \"\",\n  \"clarificationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"abortStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"idleSessionTTLInSeconds\": 0,\n  \"voiceId\": \"\",\n  \"checksum\": \"\",\n  \"processBehavior\": \"\",\n  \"locale\": \"\",\n  \"childDirected\": false,\n  \"detectSentiment\": false,\n  \"createVersion\": false,\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/bots/:name/versions/$LATEST")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/bots/:name/versions/$LATEST")
  .header("content-type", "application/json")
  .body("{\n  \"description\": \"\",\n  \"intents\": [\n    {\n      \"intentName\": \"\",\n      \"intentVersion\": \"\"\n    }\n  ],\n  \"enableModelImprovements\": false,\n  \"nluIntentConfidenceThreshold\": \"\",\n  \"clarificationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"abortStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"idleSessionTTLInSeconds\": 0,\n  \"voiceId\": \"\",\n  \"checksum\": \"\",\n  \"processBehavior\": \"\",\n  \"locale\": \"\",\n  \"childDirected\": false,\n  \"detectSentiment\": false,\n  \"createVersion\": false,\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  description: '',
  intents: [
    {
      intentName: '',
      intentVersion: ''
    }
  ],
  enableModelImprovements: false,
  nluIntentConfidenceThreshold: '',
  clarificationPrompt: {
    messages: '',
    maxAttempts: '',
    responseCard: ''
  },
  abortStatement: {
    messages: '',
    responseCard: ''
  },
  idleSessionTTLInSeconds: 0,
  voiceId: '',
  checksum: '',
  processBehavior: '',
  locale: '',
  childDirected: false,
  detectSentiment: false,
  createVersion: false,
  tags: [
    {
      key: '',
      value: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/bots/:name/versions/$LATEST');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/bots/:name/versions/$LATEST',
  headers: {'content-type': 'application/json'},
  data: {
    description: '',
    intents: [{intentName: '', intentVersion: ''}],
    enableModelImprovements: false,
    nluIntentConfidenceThreshold: '',
    clarificationPrompt: {messages: '', maxAttempts: '', responseCard: ''},
    abortStatement: {messages: '', responseCard: ''},
    idleSessionTTLInSeconds: 0,
    voiceId: '',
    checksum: '',
    processBehavior: '',
    locale: '',
    childDirected: false,
    detectSentiment: false,
    createVersion: false,
    tags: [{key: '', value: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bots/:name/versions/$LATEST';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","intents":[{"intentName":"","intentVersion":""}],"enableModelImprovements":false,"nluIntentConfidenceThreshold":"","clarificationPrompt":{"messages":"","maxAttempts":"","responseCard":""},"abortStatement":{"messages":"","responseCard":""},"idleSessionTTLInSeconds":0,"voiceId":"","checksum":"","processBehavior":"","locale":"","childDirected":false,"detectSentiment":false,"createVersion":false,"tags":[{"key":"","value":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/bots/:name/versions/$LATEST',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "description": "",\n  "intents": [\n    {\n      "intentName": "",\n      "intentVersion": ""\n    }\n  ],\n  "enableModelImprovements": false,\n  "nluIntentConfidenceThreshold": "",\n  "clarificationPrompt": {\n    "messages": "",\n    "maxAttempts": "",\n    "responseCard": ""\n  },\n  "abortStatement": {\n    "messages": "",\n    "responseCard": ""\n  },\n  "idleSessionTTLInSeconds": 0,\n  "voiceId": "",\n  "checksum": "",\n  "processBehavior": "",\n  "locale": "",\n  "childDirected": false,\n  "detectSentiment": false,\n  "createVersion": false,\n  "tags": [\n    {\n      "key": "",\n      "value": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"intents\": [\n    {\n      \"intentName\": \"\",\n      \"intentVersion\": \"\"\n    }\n  ],\n  \"enableModelImprovements\": false,\n  \"nluIntentConfidenceThreshold\": \"\",\n  \"clarificationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"abortStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"idleSessionTTLInSeconds\": 0,\n  \"voiceId\": \"\",\n  \"checksum\": \"\",\n  \"processBehavior\": \"\",\n  \"locale\": \"\",\n  \"childDirected\": false,\n  \"detectSentiment\": false,\n  \"createVersion\": false,\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/bots/:name/versions/$LATEST")
  .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/bots/:name/versions/$LATEST',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  description: '',
  intents: [{intentName: '', intentVersion: ''}],
  enableModelImprovements: false,
  nluIntentConfidenceThreshold: '',
  clarificationPrompt: {messages: '', maxAttempts: '', responseCard: ''},
  abortStatement: {messages: '', responseCard: ''},
  idleSessionTTLInSeconds: 0,
  voiceId: '',
  checksum: '',
  processBehavior: '',
  locale: '',
  childDirected: false,
  detectSentiment: false,
  createVersion: false,
  tags: [{key: '', value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/bots/:name/versions/$LATEST',
  headers: {'content-type': 'application/json'},
  body: {
    description: '',
    intents: [{intentName: '', intentVersion: ''}],
    enableModelImprovements: false,
    nluIntentConfidenceThreshold: '',
    clarificationPrompt: {messages: '', maxAttempts: '', responseCard: ''},
    abortStatement: {messages: '', responseCard: ''},
    idleSessionTTLInSeconds: 0,
    voiceId: '',
    checksum: '',
    processBehavior: '',
    locale: '',
    childDirected: false,
    detectSentiment: false,
    createVersion: false,
    tags: [{key: '', value: ''}]
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/bots/:name/versions/$LATEST');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  description: '',
  intents: [
    {
      intentName: '',
      intentVersion: ''
    }
  ],
  enableModelImprovements: false,
  nluIntentConfidenceThreshold: '',
  clarificationPrompt: {
    messages: '',
    maxAttempts: '',
    responseCard: ''
  },
  abortStatement: {
    messages: '',
    responseCard: ''
  },
  idleSessionTTLInSeconds: 0,
  voiceId: '',
  checksum: '',
  processBehavior: '',
  locale: '',
  childDirected: false,
  detectSentiment: false,
  createVersion: false,
  tags: [
    {
      key: '',
      value: ''
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/bots/:name/versions/$LATEST',
  headers: {'content-type': 'application/json'},
  data: {
    description: '',
    intents: [{intentName: '', intentVersion: ''}],
    enableModelImprovements: false,
    nluIntentConfidenceThreshold: '',
    clarificationPrompt: {messages: '', maxAttempts: '', responseCard: ''},
    abortStatement: {messages: '', responseCard: ''},
    idleSessionTTLInSeconds: 0,
    voiceId: '',
    checksum: '',
    processBehavior: '',
    locale: '',
    childDirected: false,
    detectSentiment: false,
    createVersion: false,
    tags: [{key: '', value: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bots/:name/versions/$LATEST';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","intents":[{"intentName":"","intentVersion":""}],"enableModelImprovements":false,"nluIntentConfidenceThreshold":"","clarificationPrompt":{"messages":"","maxAttempts":"","responseCard":""},"abortStatement":{"messages":"","responseCard":""},"idleSessionTTLInSeconds":0,"voiceId":"","checksum":"","processBehavior":"","locale":"","childDirected":false,"detectSentiment":false,"createVersion":false,"tags":[{"key":"","value":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"description": @"",
                              @"intents": @[ @{ @"intentName": @"", @"intentVersion": @"" } ],
                              @"enableModelImprovements": @NO,
                              @"nluIntentConfidenceThreshold": @"",
                              @"clarificationPrompt": @{ @"messages": @"", @"maxAttempts": @"", @"responseCard": @"" },
                              @"abortStatement": @{ @"messages": @"", @"responseCard": @"" },
                              @"idleSessionTTLInSeconds": @0,
                              @"voiceId": @"",
                              @"checksum": @"",
                              @"processBehavior": @"",
                              @"locale": @"",
                              @"childDirected": @NO,
                              @"detectSentiment": @NO,
                              @"createVersion": @NO,
                              @"tags": @[ @{ @"key": @"", @"value": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/bots/:name/versions/$LATEST"]
                                                       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}}/bots/:name/versions/$LATEST" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"description\": \"\",\n  \"intents\": [\n    {\n      \"intentName\": \"\",\n      \"intentVersion\": \"\"\n    }\n  ],\n  \"enableModelImprovements\": false,\n  \"nluIntentConfidenceThreshold\": \"\",\n  \"clarificationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"abortStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"idleSessionTTLInSeconds\": 0,\n  \"voiceId\": \"\",\n  \"checksum\": \"\",\n  \"processBehavior\": \"\",\n  \"locale\": \"\",\n  \"childDirected\": false,\n  \"detectSentiment\": false,\n  \"createVersion\": false,\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bots/:name/versions/$LATEST",
  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([
    'description' => '',
    'intents' => [
        [
                'intentName' => '',
                'intentVersion' => ''
        ]
    ],
    'enableModelImprovements' => null,
    'nluIntentConfidenceThreshold' => '',
    'clarificationPrompt' => [
        'messages' => '',
        'maxAttempts' => '',
        'responseCard' => ''
    ],
    'abortStatement' => [
        'messages' => '',
        'responseCard' => ''
    ],
    'idleSessionTTLInSeconds' => 0,
    'voiceId' => '',
    'checksum' => '',
    'processBehavior' => '',
    'locale' => '',
    'childDirected' => null,
    'detectSentiment' => null,
    'createVersion' => null,
    'tags' => [
        [
                'key' => '',
                'value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/bots/:name/versions/$LATEST', [
  'body' => '{
  "description": "",
  "intents": [
    {
      "intentName": "",
      "intentVersion": ""
    }
  ],
  "enableModelImprovements": false,
  "nluIntentConfidenceThreshold": "",
  "clarificationPrompt": {
    "messages": "",
    "maxAttempts": "",
    "responseCard": ""
  },
  "abortStatement": {
    "messages": "",
    "responseCard": ""
  },
  "idleSessionTTLInSeconds": 0,
  "voiceId": "",
  "checksum": "",
  "processBehavior": "",
  "locale": "",
  "childDirected": false,
  "detectSentiment": false,
  "createVersion": false,
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/bots/:name/versions/$LATEST');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'description' => '',
  'intents' => [
    [
        'intentName' => '',
        'intentVersion' => ''
    ]
  ],
  'enableModelImprovements' => null,
  'nluIntentConfidenceThreshold' => '',
  'clarificationPrompt' => [
    'messages' => '',
    'maxAttempts' => '',
    'responseCard' => ''
  ],
  'abortStatement' => [
    'messages' => '',
    'responseCard' => ''
  ],
  'idleSessionTTLInSeconds' => 0,
  'voiceId' => '',
  'checksum' => '',
  'processBehavior' => '',
  'locale' => '',
  'childDirected' => null,
  'detectSentiment' => null,
  'createVersion' => null,
  'tags' => [
    [
        'key' => '',
        'value' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'description' => '',
  'intents' => [
    [
        'intentName' => '',
        'intentVersion' => ''
    ]
  ],
  'enableModelImprovements' => null,
  'nluIntentConfidenceThreshold' => '',
  'clarificationPrompt' => [
    'messages' => '',
    'maxAttempts' => '',
    'responseCard' => ''
  ],
  'abortStatement' => [
    'messages' => '',
    'responseCard' => ''
  ],
  'idleSessionTTLInSeconds' => 0,
  'voiceId' => '',
  'checksum' => '',
  'processBehavior' => '',
  'locale' => '',
  'childDirected' => null,
  'detectSentiment' => null,
  'createVersion' => null,
  'tags' => [
    [
        'key' => '',
        'value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/bots/:name/versions/$LATEST');
$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}}/bots/:name/versions/$LATEST' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "intents": [
    {
      "intentName": "",
      "intentVersion": ""
    }
  ],
  "enableModelImprovements": false,
  "nluIntentConfidenceThreshold": "",
  "clarificationPrompt": {
    "messages": "",
    "maxAttempts": "",
    "responseCard": ""
  },
  "abortStatement": {
    "messages": "",
    "responseCard": ""
  },
  "idleSessionTTLInSeconds": 0,
  "voiceId": "",
  "checksum": "",
  "processBehavior": "",
  "locale": "",
  "childDirected": false,
  "detectSentiment": false,
  "createVersion": false,
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/bots/:name/versions/$LATEST' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "intents": [
    {
      "intentName": "",
      "intentVersion": ""
    }
  ],
  "enableModelImprovements": false,
  "nluIntentConfidenceThreshold": "",
  "clarificationPrompt": {
    "messages": "",
    "maxAttempts": "",
    "responseCard": ""
  },
  "abortStatement": {
    "messages": "",
    "responseCard": ""
  },
  "idleSessionTTLInSeconds": 0,
  "voiceId": "",
  "checksum": "",
  "processBehavior": "",
  "locale": "",
  "childDirected": false,
  "detectSentiment": false,
  "createVersion": false,
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"description\": \"\",\n  \"intents\": [\n    {\n      \"intentName\": \"\",\n      \"intentVersion\": \"\"\n    }\n  ],\n  \"enableModelImprovements\": false,\n  \"nluIntentConfidenceThreshold\": \"\",\n  \"clarificationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"abortStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"idleSessionTTLInSeconds\": 0,\n  \"voiceId\": \"\",\n  \"checksum\": \"\",\n  \"processBehavior\": \"\",\n  \"locale\": \"\",\n  \"childDirected\": false,\n  \"detectSentiment\": false,\n  \"createVersion\": false,\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/bots/:name/versions/$LATEST", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bots/:name/versions/$LATEST"

payload = {
    "description": "",
    "intents": [
        {
            "intentName": "",
            "intentVersion": ""
        }
    ],
    "enableModelImprovements": False,
    "nluIntentConfidenceThreshold": "",
    "clarificationPrompt": {
        "messages": "",
        "maxAttempts": "",
        "responseCard": ""
    },
    "abortStatement": {
        "messages": "",
        "responseCard": ""
    },
    "idleSessionTTLInSeconds": 0,
    "voiceId": "",
    "checksum": "",
    "processBehavior": "",
    "locale": "",
    "childDirected": False,
    "detectSentiment": False,
    "createVersion": False,
    "tags": [
        {
            "key": "",
            "value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bots/:name/versions/$LATEST"

payload <- "{\n  \"description\": \"\",\n  \"intents\": [\n    {\n      \"intentName\": \"\",\n      \"intentVersion\": \"\"\n    }\n  ],\n  \"enableModelImprovements\": false,\n  \"nluIntentConfidenceThreshold\": \"\",\n  \"clarificationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"abortStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"idleSessionTTLInSeconds\": 0,\n  \"voiceId\": \"\",\n  \"checksum\": \"\",\n  \"processBehavior\": \"\",\n  \"locale\": \"\",\n  \"childDirected\": false,\n  \"detectSentiment\": false,\n  \"createVersion\": false,\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\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}}/bots/:name/versions/$LATEST")

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  \"description\": \"\",\n  \"intents\": [\n    {\n      \"intentName\": \"\",\n      \"intentVersion\": \"\"\n    }\n  ],\n  \"enableModelImprovements\": false,\n  \"nluIntentConfidenceThreshold\": \"\",\n  \"clarificationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"abortStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"idleSessionTTLInSeconds\": 0,\n  \"voiceId\": \"\",\n  \"checksum\": \"\",\n  \"processBehavior\": \"\",\n  \"locale\": \"\",\n  \"childDirected\": false,\n  \"detectSentiment\": false,\n  \"createVersion\": false,\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/bots/:name/versions/$LATEST') do |req|
  req.body = "{\n  \"description\": \"\",\n  \"intents\": [\n    {\n      \"intentName\": \"\",\n      \"intentVersion\": \"\"\n    }\n  ],\n  \"enableModelImprovements\": false,\n  \"nluIntentConfidenceThreshold\": \"\",\n  \"clarificationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"abortStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"idleSessionTTLInSeconds\": 0,\n  \"voiceId\": \"\",\n  \"checksum\": \"\",\n  \"processBehavior\": \"\",\n  \"locale\": \"\",\n  \"childDirected\": false,\n  \"detectSentiment\": false,\n  \"createVersion\": false,\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\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}}/bots/:name/versions/$LATEST";

    let payload = json!({
        "description": "",
        "intents": (
            json!({
                "intentName": "",
                "intentVersion": ""
            })
        ),
        "enableModelImprovements": false,
        "nluIntentConfidenceThreshold": "",
        "clarificationPrompt": json!({
            "messages": "",
            "maxAttempts": "",
            "responseCard": ""
        }),
        "abortStatement": json!({
            "messages": "",
            "responseCard": ""
        }),
        "idleSessionTTLInSeconds": 0,
        "voiceId": "",
        "checksum": "",
        "processBehavior": "",
        "locale": "",
        "childDirected": false,
        "detectSentiment": false,
        "createVersion": false,
        "tags": (
            json!({
                "key": "",
                "value": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "description": "",
  "intents": [
    {
      "intentName": "",
      "intentVersion": ""
    }
  ],
  "enableModelImprovements": false,
  "nluIntentConfidenceThreshold": "",
  "clarificationPrompt": {
    "messages": "",
    "maxAttempts": "",
    "responseCard": ""
  },
  "abortStatement": {
    "messages": "",
    "responseCard": ""
  },
  "idleSessionTTLInSeconds": 0,
  "voiceId": "",
  "checksum": "",
  "processBehavior": "",
  "locale": "",
  "childDirected": false,
  "detectSentiment": false,
  "createVersion": false,
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}' |  \
  http PUT '{{baseUrl}}/bots/:name/versions/$LATEST' \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "description": "",\n  "intents": [\n    {\n      "intentName": "",\n      "intentVersion": ""\n    }\n  ],\n  "enableModelImprovements": false,\n  "nluIntentConfidenceThreshold": "",\n  "clarificationPrompt": {\n    "messages": "",\n    "maxAttempts": "",\n    "responseCard": ""\n  },\n  "abortStatement": {\n    "messages": "",\n    "responseCard": ""\n  },\n  "idleSessionTTLInSeconds": 0,\n  "voiceId": "",\n  "checksum": "",\n  "processBehavior": "",\n  "locale": "",\n  "childDirected": false,\n  "detectSentiment": false,\n  "createVersion": false,\n  "tags": [\n    {\n      "key": "",\n      "value": ""\n    }\n  ]\n}' \
  --output-document \
  - '{{baseUrl}}/bots/:name/versions/$LATEST'

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "description": "",
  "intents": [
    [
      "intentName": "",
      "intentVersion": ""
    ]
  ],
  "enableModelImprovements": false,
  "nluIntentConfidenceThreshold": "",
  "clarificationPrompt": [
    "messages": "",
    "maxAttempts": "",
    "responseCard": ""
  ],
  "abortStatement": [
    "messages": "",
    "responseCard": ""
  ],
  "idleSessionTTLInSeconds": 0,
  "voiceId": "",
  "checksum": "",
  "processBehavior": "",
  "locale": "",
  "childDirected": false,
  "detectSentiment": false,
  "createVersion": false,
  "tags": [
    [
      "key": "",
      "value": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bots/:name/versions/$LATEST")! 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}}/bots/:botName/aliases/:name");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"description\": \"\",\n  \"botVersion\": \"\",\n  \"checksum\": \"\",\n  \"conversationLogs\": {\n    \"logSettings\": \"\",\n    \"iamRoleArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/bots/:botName/aliases/:name" {:content-type :json
                                                                       :form-params {:description ""
                                                                                     :botVersion ""
                                                                                     :checksum ""
                                                                                     :conversationLogs {:logSettings ""
                                                                                                        :iamRoleArn ""}
                                                                                     :tags [{:key ""
                                                                                             :value ""}]}})

require "http/client"

url = "{{baseUrl}}/bots/:botName/aliases/:name"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"description\": \"\",\n  \"botVersion\": \"\",\n  \"checksum\": \"\",\n  \"conversationLogs\": {\n    \"logSettings\": \"\",\n    \"iamRoleArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\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}}/bots/:botName/aliases/:name"),
    Content = new StringContent("{\n  \"description\": \"\",\n  \"botVersion\": \"\",\n  \"checksum\": \"\",\n  \"conversationLogs\": {\n    \"logSettings\": \"\",\n    \"iamRoleArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/bots/:botName/aliases/:name");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"description\": \"\",\n  \"botVersion\": \"\",\n  \"checksum\": \"\",\n  \"conversationLogs\": {\n    \"logSettings\": \"\",\n    \"iamRoleArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/bots/:botName/aliases/:name"

	payload := strings.NewReader("{\n  \"description\": \"\",\n  \"botVersion\": \"\",\n  \"checksum\": \"\",\n  \"conversationLogs\": {\n    \"logSettings\": \"\",\n    \"iamRoleArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\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/bots/:botName/aliases/:name HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 198

{
  "description": "",
  "botVersion": "",
  "checksum": "",
  "conversationLogs": {
    "logSettings": "",
    "iamRoleArn": ""
  },
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/bots/:botName/aliases/:name")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"description\": \"\",\n  \"botVersion\": \"\",\n  \"checksum\": \"\",\n  \"conversationLogs\": {\n    \"logSettings\": \"\",\n    \"iamRoleArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/bots/:botName/aliases/:name"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"description\": \"\",\n  \"botVersion\": \"\",\n  \"checksum\": \"\",\n  \"conversationLogs\": {\n    \"logSettings\": \"\",\n    \"iamRoleArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"botVersion\": \"\",\n  \"checksum\": \"\",\n  \"conversationLogs\": {\n    \"logSettings\": \"\",\n    \"iamRoleArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/bots/:botName/aliases/:name")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/bots/:botName/aliases/:name")
  .header("content-type", "application/json")
  .body("{\n  \"description\": \"\",\n  \"botVersion\": \"\",\n  \"checksum\": \"\",\n  \"conversationLogs\": {\n    \"logSettings\": \"\",\n    \"iamRoleArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  description: '',
  botVersion: '',
  checksum: '',
  conversationLogs: {
    logSettings: '',
    iamRoleArn: ''
  },
  tags: [
    {
      key: '',
      value: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/bots/:botName/aliases/:name');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/bots/:botName/aliases/:name',
  headers: {'content-type': 'application/json'},
  data: {
    description: '',
    botVersion: '',
    checksum: '',
    conversationLogs: {logSettings: '', iamRoleArn: ''},
    tags: [{key: '', value: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/bots/:botName/aliases/:name';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","botVersion":"","checksum":"","conversationLogs":{"logSettings":"","iamRoleArn":""},"tags":[{"key":"","value":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/bots/:botName/aliases/:name',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "description": "",\n  "botVersion": "",\n  "checksum": "",\n  "conversationLogs": {\n    "logSettings": "",\n    "iamRoleArn": ""\n  },\n  "tags": [\n    {\n      "key": "",\n      "value": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"botVersion\": \"\",\n  \"checksum\": \"\",\n  \"conversationLogs\": {\n    \"logSettings\": \"\",\n    \"iamRoleArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/bots/:botName/aliases/:name")
  .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/bots/:botName/aliases/:name',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  description: '',
  botVersion: '',
  checksum: '',
  conversationLogs: {logSettings: '', iamRoleArn: ''},
  tags: [{key: '', value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/bots/:botName/aliases/:name',
  headers: {'content-type': 'application/json'},
  body: {
    description: '',
    botVersion: '',
    checksum: '',
    conversationLogs: {logSettings: '', iamRoleArn: ''},
    tags: [{key: '', value: ''}]
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/bots/:botName/aliases/:name');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  description: '',
  botVersion: '',
  checksum: '',
  conversationLogs: {
    logSettings: '',
    iamRoleArn: ''
  },
  tags: [
    {
      key: '',
      value: ''
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/bots/:botName/aliases/:name',
  headers: {'content-type': 'application/json'},
  data: {
    description: '',
    botVersion: '',
    checksum: '',
    conversationLogs: {logSettings: '', iamRoleArn: ''},
    tags: [{key: '', value: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/bots/:botName/aliases/:name';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","botVersion":"","checksum":"","conversationLogs":{"logSettings":"","iamRoleArn":""},"tags":[{"key":"","value":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"description": @"",
                              @"botVersion": @"",
                              @"checksum": @"",
                              @"conversationLogs": @{ @"logSettings": @"", @"iamRoleArn": @"" },
                              @"tags": @[ @{ @"key": @"", @"value": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/bots/:botName/aliases/:name"]
                                                       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}}/bots/:botName/aliases/:name" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"description\": \"\",\n  \"botVersion\": \"\",\n  \"checksum\": \"\",\n  \"conversationLogs\": {\n    \"logSettings\": \"\",\n    \"iamRoleArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/bots/:botName/aliases/:name",
  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([
    'description' => '',
    'botVersion' => '',
    'checksum' => '',
    'conversationLogs' => [
        'logSettings' => '',
        'iamRoleArn' => ''
    ],
    'tags' => [
        [
                'key' => '',
                'value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/bots/:botName/aliases/:name', [
  'body' => '{
  "description": "",
  "botVersion": "",
  "checksum": "",
  "conversationLogs": {
    "logSettings": "",
    "iamRoleArn": ""
  },
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/bots/:botName/aliases/:name');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'description' => '',
  'botVersion' => '',
  'checksum' => '',
  'conversationLogs' => [
    'logSettings' => '',
    'iamRoleArn' => ''
  ],
  'tags' => [
    [
        'key' => '',
        'value' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'description' => '',
  'botVersion' => '',
  'checksum' => '',
  'conversationLogs' => [
    'logSettings' => '',
    'iamRoleArn' => ''
  ],
  'tags' => [
    [
        'key' => '',
        'value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/bots/:botName/aliases/:name');
$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}}/bots/:botName/aliases/:name' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "botVersion": "",
  "checksum": "",
  "conversationLogs": {
    "logSettings": "",
    "iamRoleArn": ""
  },
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/bots/:botName/aliases/:name' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "botVersion": "",
  "checksum": "",
  "conversationLogs": {
    "logSettings": "",
    "iamRoleArn": ""
  },
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"description\": \"\",\n  \"botVersion\": \"\",\n  \"checksum\": \"\",\n  \"conversationLogs\": {\n    \"logSettings\": \"\",\n    \"iamRoleArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/bots/:botName/aliases/:name", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/bots/:botName/aliases/:name"

payload = {
    "description": "",
    "botVersion": "",
    "checksum": "",
    "conversationLogs": {
        "logSettings": "",
        "iamRoleArn": ""
    },
    "tags": [
        {
            "key": "",
            "value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/bots/:botName/aliases/:name"

payload <- "{\n  \"description\": \"\",\n  \"botVersion\": \"\",\n  \"checksum\": \"\",\n  \"conversationLogs\": {\n    \"logSettings\": \"\",\n    \"iamRoleArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\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}}/bots/:botName/aliases/:name")

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  \"description\": \"\",\n  \"botVersion\": \"\",\n  \"checksum\": \"\",\n  \"conversationLogs\": {\n    \"logSettings\": \"\",\n    \"iamRoleArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/bots/:botName/aliases/:name') do |req|
  req.body = "{\n  \"description\": \"\",\n  \"botVersion\": \"\",\n  \"checksum\": \"\",\n  \"conversationLogs\": {\n    \"logSettings\": \"\",\n    \"iamRoleArn\": \"\"\n  },\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\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}}/bots/:botName/aliases/:name";

    let payload = json!({
        "description": "",
        "botVersion": "",
        "checksum": "",
        "conversationLogs": json!({
            "logSettings": "",
            "iamRoleArn": ""
        }),
        "tags": (
            json!({
                "key": "",
                "value": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "description": "",
  "botVersion": "",
  "checksum": "",
  "conversationLogs": {
    "logSettings": "",
    "iamRoleArn": ""
  },
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}' |  \
  http PUT {{baseUrl}}/bots/:botName/aliases/:name \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "description": "",\n  "botVersion": "",\n  "checksum": "",\n  "conversationLogs": {\n    "logSettings": "",\n    "iamRoleArn": ""\n  },\n  "tags": [\n    {\n      "key": "",\n      "value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/bots/:botName/aliases/:name

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "description": "",
  "botVersion": "",
  "checksum": "",
  "conversationLogs": [
    "logSettings": "",
    "iamRoleArn": ""
  ],
  "tags": [
    [
      "key": "",
      "value": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/bots/:botName/aliases/:name")! 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}}/intents/:name/versions/$LATEST");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"description\": \"\",\n  \"slots\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"slotConstraint\": \"\",\n      \"slotType\": \"\",\n      \"slotTypeVersion\": \"\",\n      \"valueElicitationPrompt\": \"\",\n      \"priority\": \"\",\n      \"sampleUtterances\": \"\",\n      \"responseCard\": \"\",\n      \"obfuscationSetting\": \"\",\n      \"defaultValueSpec\": \"\"\n    }\n  ],\n  \"sampleUtterances\": [],\n  \"confirmationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"rejectionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"followUpPrompt\": {\n    \"prompt\": \"\",\n    \"rejectionStatement\": \"\"\n  },\n  \"conclusionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"dialogCodeHook\": {\n    \"uri\": \"\",\n    \"messageVersion\": \"\"\n  },\n  \"fulfillmentActivity\": {\n    \"type\": \"\",\n    \"codeHook\": \"\"\n  },\n  \"parentIntentSignature\": \"\",\n  \"checksum\": \"\",\n  \"createVersion\": false,\n  \"kendraConfiguration\": {\n    \"kendraIndex\": \"\",\n    \"queryFilterString\": \"\",\n    \"role\": \"\"\n  },\n  \"inputContexts\": [\n    {\n      \"name\": \"\"\n    }\n  ],\n  \"outputContexts\": [\n    {\n      \"name\": \"\",\n      \"timeToLiveInSeconds\": \"\",\n      \"turnsToLive\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/intents/:name/versions/$LATEST" {:content-type :json
                                                                          :form-params {:description ""
                                                                                        :slots [{:name ""
                                                                                                 :description ""
                                                                                                 :slotConstraint ""
                                                                                                 :slotType ""
                                                                                                 :slotTypeVersion ""
                                                                                                 :valueElicitationPrompt ""
                                                                                                 :priority ""
                                                                                                 :sampleUtterances ""
                                                                                                 :responseCard ""
                                                                                                 :obfuscationSetting ""
                                                                                                 :defaultValueSpec ""}]
                                                                                        :sampleUtterances []
                                                                                        :confirmationPrompt {:messages ""
                                                                                                             :maxAttempts ""
                                                                                                             :responseCard ""}
                                                                                        :rejectionStatement {:messages ""
                                                                                                             :responseCard ""}
                                                                                        :followUpPrompt {:prompt ""
                                                                                                         :rejectionStatement ""}
                                                                                        :conclusionStatement {:messages ""
                                                                                                              :responseCard ""}
                                                                                        :dialogCodeHook {:uri ""
                                                                                                         :messageVersion ""}
                                                                                        :fulfillmentActivity {:type ""
                                                                                                              :codeHook ""}
                                                                                        :parentIntentSignature ""
                                                                                        :checksum ""
                                                                                        :createVersion false
                                                                                        :kendraConfiguration {:kendraIndex ""
                                                                                                              :queryFilterString ""
                                                                                                              :role ""}
                                                                                        :inputContexts [{:name ""}]
                                                                                        :outputContexts [{:name ""
                                                                                                          :timeToLiveInSeconds ""
                                                                                                          :turnsToLive ""}]}})

require "http/client"

url = "{{baseUrl}}/intents/:name/versions/$LATEST"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"description\": \"\",\n  \"slots\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"slotConstraint\": \"\",\n      \"slotType\": \"\",\n      \"slotTypeVersion\": \"\",\n      \"valueElicitationPrompt\": \"\",\n      \"priority\": \"\",\n      \"sampleUtterances\": \"\",\n      \"responseCard\": \"\",\n      \"obfuscationSetting\": \"\",\n      \"defaultValueSpec\": \"\"\n    }\n  ],\n  \"sampleUtterances\": [],\n  \"confirmationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"rejectionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"followUpPrompt\": {\n    \"prompt\": \"\",\n    \"rejectionStatement\": \"\"\n  },\n  \"conclusionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"dialogCodeHook\": {\n    \"uri\": \"\",\n    \"messageVersion\": \"\"\n  },\n  \"fulfillmentActivity\": {\n    \"type\": \"\",\n    \"codeHook\": \"\"\n  },\n  \"parentIntentSignature\": \"\",\n  \"checksum\": \"\",\n  \"createVersion\": false,\n  \"kendraConfiguration\": {\n    \"kendraIndex\": \"\",\n    \"queryFilterString\": \"\",\n    \"role\": \"\"\n  },\n  \"inputContexts\": [\n    {\n      \"name\": \"\"\n    }\n  ],\n  \"outputContexts\": [\n    {\n      \"name\": \"\",\n      \"timeToLiveInSeconds\": \"\",\n      \"turnsToLive\": \"\"\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}}/intents/:name/versions/$LATEST"),
    Content = new StringContent("{\n  \"description\": \"\",\n  \"slots\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"slotConstraint\": \"\",\n      \"slotType\": \"\",\n      \"slotTypeVersion\": \"\",\n      \"valueElicitationPrompt\": \"\",\n      \"priority\": \"\",\n      \"sampleUtterances\": \"\",\n      \"responseCard\": \"\",\n      \"obfuscationSetting\": \"\",\n      \"defaultValueSpec\": \"\"\n    }\n  ],\n  \"sampleUtterances\": [],\n  \"confirmationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"rejectionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"followUpPrompt\": {\n    \"prompt\": \"\",\n    \"rejectionStatement\": \"\"\n  },\n  \"conclusionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"dialogCodeHook\": {\n    \"uri\": \"\",\n    \"messageVersion\": \"\"\n  },\n  \"fulfillmentActivity\": {\n    \"type\": \"\",\n    \"codeHook\": \"\"\n  },\n  \"parentIntentSignature\": \"\",\n  \"checksum\": \"\",\n  \"createVersion\": false,\n  \"kendraConfiguration\": {\n    \"kendraIndex\": \"\",\n    \"queryFilterString\": \"\",\n    \"role\": \"\"\n  },\n  \"inputContexts\": [\n    {\n      \"name\": \"\"\n    }\n  ],\n  \"outputContexts\": [\n    {\n      \"name\": \"\",\n      \"timeToLiveInSeconds\": \"\",\n      \"turnsToLive\": \"\"\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}}/intents/:name/versions/$LATEST");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"description\": \"\",\n  \"slots\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"slotConstraint\": \"\",\n      \"slotType\": \"\",\n      \"slotTypeVersion\": \"\",\n      \"valueElicitationPrompt\": \"\",\n      \"priority\": \"\",\n      \"sampleUtterances\": \"\",\n      \"responseCard\": \"\",\n      \"obfuscationSetting\": \"\",\n      \"defaultValueSpec\": \"\"\n    }\n  ],\n  \"sampleUtterances\": [],\n  \"confirmationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"rejectionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"followUpPrompt\": {\n    \"prompt\": \"\",\n    \"rejectionStatement\": \"\"\n  },\n  \"conclusionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"dialogCodeHook\": {\n    \"uri\": \"\",\n    \"messageVersion\": \"\"\n  },\n  \"fulfillmentActivity\": {\n    \"type\": \"\",\n    \"codeHook\": \"\"\n  },\n  \"parentIntentSignature\": \"\",\n  \"checksum\": \"\",\n  \"createVersion\": false,\n  \"kendraConfiguration\": {\n    \"kendraIndex\": \"\",\n    \"queryFilterString\": \"\",\n    \"role\": \"\"\n  },\n  \"inputContexts\": [\n    {\n      \"name\": \"\"\n    }\n  ],\n  \"outputContexts\": [\n    {\n      \"name\": \"\",\n      \"timeToLiveInSeconds\": \"\",\n      \"turnsToLive\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/intents/:name/versions/$LATEST"

	payload := strings.NewReader("{\n  \"description\": \"\",\n  \"slots\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"slotConstraint\": \"\",\n      \"slotType\": \"\",\n      \"slotTypeVersion\": \"\",\n      \"valueElicitationPrompt\": \"\",\n      \"priority\": \"\",\n      \"sampleUtterances\": \"\",\n      \"responseCard\": \"\",\n      \"obfuscationSetting\": \"\",\n      \"defaultValueSpec\": \"\"\n    }\n  ],\n  \"sampleUtterances\": [],\n  \"confirmationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"rejectionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"followUpPrompt\": {\n    \"prompt\": \"\",\n    \"rejectionStatement\": \"\"\n  },\n  \"conclusionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"dialogCodeHook\": {\n    \"uri\": \"\",\n    \"messageVersion\": \"\"\n  },\n  \"fulfillmentActivity\": {\n    \"type\": \"\",\n    \"codeHook\": \"\"\n  },\n  \"parentIntentSignature\": \"\",\n  \"checksum\": \"\",\n  \"createVersion\": false,\n  \"kendraConfiguration\": {\n    \"kendraIndex\": \"\",\n    \"queryFilterString\": \"\",\n    \"role\": \"\"\n  },\n  \"inputContexts\": [\n    {\n      \"name\": \"\"\n    }\n  ],\n  \"outputContexts\": [\n    {\n      \"name\": \"\",\n      \"timeToLiveInSeconds\": \"\",\n      \"turnsToLive\": \"\"\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/intents/:name/versions/$LATEST HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1173

{
  "description": "",
  "slots": [
    {
      "name": "",
      "description": "",
      "slotConstraint": "",
      "slotType": "",
      "slotTypeVersion": "",
      "valueElicitationPrompt": "",
      "priority": "",
      "sampleUtterances": "",
      "responseCard": "",
      "obfuscationSetting": "",
      "defaultValueSpec": ""
    }
  ],
  "sampleUtterances": [],
  "confirmationPrompt": {
    "messages": "",
    "maxAttempts": "",
    "responseCard": ""
  },
  "rejectionStatement": {
    "messages": "",
    "responseCard": ""
  },
  "followUpPrompt": {
    "prompt": "",
    "rejectionStatement": ""
  },
  "conclusionStatement": {
    "messages": "",
    "responseCard": ""
  },
  "dialogCodeHook": {
    "uri": "",
    "messageVersion": ""
  },
  "fulfillmentActivity": {
    "type": "",
    "codeHook": ""
  },
  "parentIntentSignature": "",
  "checksum": "",
  "createVersion": false,
  "kendraConfiguration": {
    "kendraIndex": "",
    "queryFilterString": "",
    "role": ""
  },
  "inputContexts": [
    {
      "name": ""
    }
  ],
  "outputContexts": [
    {
      "name": "",
      "timeToLiveInSeconds": "",
      "turnsToLive": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/intents/:name/versions/$LATEST")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"description\": \"\",\n  \"slots\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"slotConstraint\": \"\",\n      \"slotType\": \"\",\n      \"slotTypeVersion\": \"\",\n      \"valueElicitationPrompt\": \"\",\n      \"priority\": \"\",\n      \"sampleUtterances\": \"\",\n      \"responseCard\": \"\",\n      \"obfuscationSetting\": \"\",\n      \"defaultValueSpec\": \"\"\n    }\n  ],\n  \"sampleUtterances\": [],\n  \"confirmationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"rejectionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"followUpPrompt\": {\n    \"prompt\": \"\",\n    \"rejectionStatement\": \"\"\n  },\n  \"conclusionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"dialogCodeHook\": {\n    \"uri\": \"\",\n    \"messageVersion\": \"\"\n  },\n  \"fulfillmentActivity\": {\n    \"type\": \"\",\n    \"codeHook\": \"\"\n  },\n  \"parentIntentSignature\": \"\",\n  \"checksum\": \"\",\n  \"createVersion\": false,\n  \"kendraConfiguration\": {\n    \"kendraIndex\": \"\",\n    \"queryFilterString\": \"\",\n    \"role\": \"\"\n  },\n  \"inputContexts\": [\n    {\n      \"name\": \"\"\n    }\n  ],\n  \"outputContexts\": [\n    {\n      \"name\": \"\",\n      \"timeToLiveInSeconds\": \"\",\n      \"turnsToLive\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/intents/:name/versions/$LATEST"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"description\": \"\",\n  \"slots\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"slotConstraint\": \"\",\n      \"slotType\": \"\",\n      \"slotTypeVersion\": \"\",\n      \"valueElicitationPrompt\": \"\",\n      \"priority\": \"\",\n      \"sampleUtterances\": \"\",\n      \"responseCard\": \"\",\n      \"obfuscationSetting\": \"\",\n      \"defaultValueSpec\": \"\"\n    }\n  ],\n  \"sampleUtterances\": [],\n  \"confirmationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"rejectionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"followUpPrompt\": {\n    \"prompt\": \"\",\n    \"rejectionStatement\": \"\"\n  },\n  \"conclusionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"dialogCodeHook\": {\n    \"uri\": \"\",\n    \"messageVersion\": \"\"\n  },\n  \"fulfillmentActivity\": {\n    \"type\": \"\",\n    \"codeHook\": \"\"\n  },\n  \"parentIntentSignature\": \"\",\n  \"checksum\": \"\",\n  \"createVersion\": false,\n  \"kendraConfiguration\": {\n    \"kendraIndex\": \"\",\n    \"queryFilterString\": \"\",\n    \"role\": \"\"\n  },\n  \"inputContexts\": [\n    {\n      \"name\": \"\"\n    }\n  ],\n  \"outputContexts\": [\n    {\n      \"name\": \"\",\n      \"timeToLiveInSeconds\": \"\",\n      \"turnsToLive\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"slots\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"slotConstraint\": \"\",\n      \"slotType\": \"\",\n      \"slotTypeVersion\": \"\",\n      \"valueElicitationPrompt\": \"\",\n      \"priority\": \"\",\n      \"sampleUtterances\": \"\",\n      \"responseCard\": \"\",\n      \"obfuscationSetting\": \"\",\n      \"defaultValueSpec\": \"\"\n    }\n  ],\n  \"sampleUtterances\": [],\n  \"confirmationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"rejectionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"followUpPrompt\": {\n    \"prompt\": \"\",\n    \"rejectionStatement\": \"\"\n  },\n  \"conclusionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"dialogCodeHook\": {\n    \"uri\": \"\",\n    \"messageVersion\": \"\"\n  },\n  \"fulfillmentActivity\": {\n    \"type\": \"\",\n    \"codeHook\": \"\"\n  },\n  \"parentIntentSignature\": \"\",\n  \"checksum\": \"\",\n  \"createVersion\": false,\n  \"kendraConfiguration\": {\n    \"kendraIndex\": \"\",\n    \"queryFilterString\": \"\",\n    \"role\": \"\"\n  },\n  \"inputContexts\": [\n    {\n      \"name\": \"\"\n    }\n  ],\n  \"outputContexts\": [\n    {\n      \"name\": \"\",\n      \"timeToLiveInSeconds\": \"\",\n      \"turnsToLive\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/intents/:name/versions/$LATEST")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/intents/:name/versions/$LATEST")
  .header("content-type", "application/json")
  .body("{\n  \"description\": \"\",\n  \"slots\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"slotConstraint\": \"\",\n      \"slotType\": \"\",\n      \"slotTypeVersion\": \"\",\n      \"valueElicitationPrompt\": \"\",\n      \"priority\": \"\",\n      \"sampleUtterances\": \"\",\n      \"responseCard\": \"\",\n      \"obfuscationSetting\": \"\",\n      \"defaultValueSpec\": \"\"\n    }\n  ],\n  \"sampleUtterances\": [],\n  \"confirmationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"rejectionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"followUpPrompt\": {\n    \"prompt\": \"\",\n    \"rejectionStatement\": \"\"\n  },\n  \"conclusionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"dialogCodeHook\": {\n    \"uri\": \"\",\n    \"messageVersion\": \"\"\n  },\n  \"fulfillmentActivity\": {\n    \"type\": \"\",\n    \"codeHook\": \"\"\n  },\n  \"parentIntentSignature\": \"\",\n  \"checksum\": \"\",\n  \"createVersion\": false,\n  \"kendraConfiguration\": {\n    \"kendraIndex\": \"\",\n    \"queryFilterString\": \"\",\n    \"role\": \"\"\n  },\n  \"inputContexts\": [\n    {\n      \"name\": \"\"\n    }\n  ],\n  \"outputContexts\": [\n    {\n      \"name\": \"\",\n      \"timeToLiveInSeconds\": \"\",\n      \"turnsToLive\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  description: '',
  slots: [
    {
      name: '',
      description: '',
      slotConstraint: '',
      slotType: '',
      slotTypeVersion: '',
      valueElicitationPrompt: '',
      priority: '',
      sampleUtterances: '',
      responseCard: '',
      obfuscationSetting: '',
      defaultValueSpec: ''
    }
  ],
  sampleUtterances: [],
  confirmationPrompt: {
    messages: '',
    maxAttempts: '',
    responseCard: ''
  },
  rejectionStatement: {
    messages: '',
    responseCard: ''
  },
  followUpPrompt: {
    prompt: '',
    rejectionStatement: ''
  },
  conclusionStatement: {
    messages: '',
    responseCard: ''
  },
  dialogCodeHook: {
    uri: '',
    messageVersion: ''
  },
  fulfillmentActivity: {
    type: '',
    codeHook: ''
  },
  parentIntentSignature: '',
  checksum: '',
  createVersion: false,
  kendraConfiguration: {
    kendraIndex: '',
    queryFilterString: '',
    role: ''
  },
  inputContexts: [
    {
      name: ''
    }
  ],
  outputContexts: [
    {
      name: '',
      timeToLiveInSeconds: '',
      turnsToLive: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/intents/:name/versions/$LATEST');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/intents/:name/versions/$LATEST',
  headers: {'content-type': 'application/json'},
  data: {
    description: '',
    slots: [
      {
        name: '',
        description: '',
        slotConstraint: '',
        slotType: '',
        slotTypeVersion: '',
        valueElicitationPrompt: '',
        priority: '',
        sampleUtterances: '',
        responseCard: '',
        obfuscationSetting: '',
        defaultValueSpec: ''
      }
    ],
    sampleUtterances: [],
    confirmationPrompt: {messages: '', maxAttempts: '', responseCard: ''},
    rejectionStatement: {messages: '', responseCard: ''},
    followUpPrompt: {prompt: '', rejectionStatement: ''},
    conclusionStatement: {messages: '', responseCard: ''},
    dialogCodeHook: {uri: '', messageVersion: ''},
    fulfillmentActivity: {type: '', codeHook: ''},
    parentIntentSignature: '',
    checksum: '',
    createVersion: false,
    kendraConfiguration: {kendraIndex: '', queryFilterString: '', role: ''},
    inputContexts: [{name: ''}],
    outputContexts: [{name: '', timeToLiveInSeconds: '', turnsToLive: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/intents/:name/versions/$LATEST';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","slots":[{"name":"","description":"","slotConstraint":"","slotType":"","slotTypeVersion":"","valueElicitationPrompt":"","priority":"","sampleUtterances":"","responseCard":"","obfuscationSetting":"","defaultValueSpec":""}],"sampleUtterances":[],"confirmationPrompt":{"messages":"","maxAttempts":"","responseCard":""},"rejectionStatement":{"messages":"","responseCard":""},"followUpPrompt":{"prompt":"","rejectionStatement":""},"conclusionStatement":{"messages":"","responseCard":""},"dialogCodeHook":{"uri":"","messageVersion":""},"fulfillmentActivity":{"type":"","codeHook":""},"parentIntentSignature":"","checksum":"","createVersion":false,"kendraConfiguration":{"kendraIndex":"","queryFilterString":"","role":""},"inputContexts":[{"name":""}],"outputContexts":[{"name":"","timeToLiveInSeconds":"","turnsToLive":""}]}'
};

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}}/intents/:name/versions/$LATEST',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "description": "",\n  "slots": [\n    {\n      "name": "",\n      "description": "",\n      "slotConstraint": "",\n      "slotType": "",\n      "slotTypeVersion": "",\n      "valueElicitationPrompt": "",\n      "priority": "",\n      "sampleUtterances": "",\n      "responseCard": "",\n      "obfuscationSetting": "",\n      "defaultValueSpec": ""\n    }\n  ],\n  "sampleUtterances": [],\n  "confirmationPrompt": {\n    "messages": "",\n    "maxAttempts": "",\n    "responseCard": ""\n  },\n  "rejectionStatement": {\n    "messages": "",\n    "responseCard": ""\n  },\n  "followUpPrompt": {\n    "prompt": "",\n    "rejectionStatement": ""\n  },\n  "conclusionStatement": {\n    "messages": "",\n    "responseCard": ""\n  },\n  "dialogCodeHook": {\n    "uri": "",\n    "messageVersion": ""\n  },\n  "fulfillmentActivity": {\n    "type": "",\n    "codeHook": ""\n  },\n  "parentIntentSignature": "",\n  "checksum": "",\n  "createVersion": false,\n  "kendraConfiguration": {\n    "kendraIndex": "",\n    "queryFilterString": "",\n    "role": ""\n  },\n  "inputContexts": [\n    {\n      "name": ""\n    }\n  ],\n  "outputContexts": [\n    {\n      "name": "",\n      "timeToLiveInSeconds": "",\n      "turnsToLive": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"slots\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"slotConstraint\": \"\",\n      \"slotType\": \"\",\n      \"slotTypeVersion\": \"\",\n      \"valueElicitationPrompt\": \"\",\n      \"priority\": \"\",\n      \"sampleUtterances\": \"\",\n      \"responseCard\": \"\",\n      \"obfuscationSetting\": \"\",\n      \"defaultValueSpec\": \"\"\n    }\n  ],\n  \"sampleUtterances\": [],\n  \"confirmationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"rejectionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"followUpPrompt\": {\n    \"prompt\": \"\",\n    \"rejectionStatement\": \"\"\n  },\n  \"conclusionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"dialogCodeHook\": {\n    \"uri\": \"\",\n    \"messageVersion\": \"\"\n  },\n  \"fulfillmentActivity\": {\n    \"type\": \"\",\n    \"codeHook\": \"\"\n  },\n  \"parentIntentSignature\": \"\",\n  \"checksum\": \"\",\n  \"createVersion\": false,\n  \"kendraConfiguration\": {\n    \"kendraIndex\": \"\",\n    \"queryFilterString\": \"\",\n    \"role\": \"\"\n  },\n  \"inputContexts\": [\n    {\n      \"name\": \"\"\n    }\n  ],\n  \"outputContexts\": [\n    {\n      \"name\": \"\",\n      \"timeToLiveInSeconds\": \"\",\n      \"turnsToLive\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/intents/:name/versions/$LATEST")
  .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/intents/:name/versions/$LATEST',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  description: '',
  slots: [
    {
      name: '',
      description: '',
      slotConstraint: '',
      slotType: '',
      slotTypeVersion: '',
      valueElicitationPrompt: '',
      priority: '',
      sampleUtterances: '',
      responseCard: '',
      obfuscationSetting: '',
      defaultValueSpec: ''
    }
  ],
  sampleUtterances: [],
  confirmationPrompt: {messages: '', maxAttempts: '', responseCard: ''},
  rejectionStatement: {messages: '', responseCard: ''},
  followUpPrompt: {prompt: '', rejectionStatement: ''},
  conclusionStatement: {messages: '', responseCard: ''},
  dialogCodeHook: {uri: '', messageVersion: ''},
  fulfillmentActivity: {type: '', codeHook: ''},
  parentIntentSignature: '',
  checksum: '',
  createVersion: false,
  kendraConfiguration: {kendraIndex: '', queryFilterString: '', role: ''},
  inputContexts: [{name: ''}],
  outputContexts: [{name: '', timeToLiveInSeconds: '', turnsToLive: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/intents/:name/versions/$LATEST',
  headers: {'content-type': 'application/json'},
  body: {
    description: '',
    slots: [
      {
        name: '',
        description: '',
        slotConstraint: '',
        slotType: '',
        slotTypeVersion: '',
        valueElicitationPrompt: '',
        priority: '',
        sampleUtterances: '',
        responseCard: '',
        obfuscationSetting: '',
        defaultValueSpec: ''
      }
    ],
    sampleUtterances: [],
    confirmationPrompt: {messages: '', maxAttempts: '', responseCard: ''},
    rejectionStatement: {messages: '', responseCard: ''},
    followUpPrompt: {prompt: '', rejectionStatement: ''},
    conclusionStatement: {messages: '', responseCard: ''},
    dialogCodeHook: {uri: '', messageVersion: ''},
    fulfillmentActivity: {type: '', codeHook: ''},
    parentIntentSignature: '',
    checksum: '',
    createVersion: false,
    kendraConfiguration: {kendraIndex: '', queryFilterString: '', role: ''},
    inputContexts: [{name: ''}],
    outputContexts: [{name: '', timeToLiveInSeconds: '', turnsToLive: ''}]
  },
  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}}/intents/:name/versions/$LATEST');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  description: '',
  slots: [
    {
      name: '',
      description: '',
      slotConstraint: '',
      slotType: '',
      slotTypeVersion: '',
      valueElicitationPrompt: '',
      priority: '',
      sampleUtterances: '',
      responseCard: '',
      obfuscationSetting: '',
      defaultValueSpec: ''
    }
  ],
  sampleUtterances: [],
  confirmationPrompt: {
    messages: '',
    maxAttempts: '',
    responseCard: ''
  },
  rejectionStatement: {
    messages: '',
    responseCard: ''
  },
  followUpPrompt: {
    prompt: '',
    rejectionStatement: ''
  },
  conclusionStatement: {
    messages: '',
    responseCard: ''
  },
  dialogCodeHook: {
    uri: '',
    messageVersion: ''
  },
  fulfillmentActivity: {
    type: '',
    codeHook: ''
  },
  parentIntentSignature: '',
  checksum: '',
  createVersion: false,
  kendraConfiguration: {
    kendraIndex: '',
    queryFilterString: '',
    role: ''
  },
  inputContexts: [
    {
      name: ''
    }
  ],
  outputContexts: [
    {
      name: '',
      timeToLiveInSeconds: '',
      turnsToLive: ''
    }
  ]
});

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}}/intents/:name/versions/$LATEST',
  headers: {'content-type': 'application/json'},
  data: {
    description: '',
    slots: [
      {
        name: '',
        description: '',
        slotConstraint: '',
        slotType: '',
        slotTypeVersion: '',
        valueElicitationPrompt: '',
        priority: '',
        sampleUtterances: '',
        responseCard: '',
        obfuscationSetting: '',
        defaultValueSpec: ''
      }
    ],
    sampleUtterances: [],
    confirmationPrompt: {messages: '', maxAttempts: '', responseCard: ''},
    rejectionStatement: {messages: '', responseCard: ''},
    followUpPrompt: {prompt: '', rejectionStatement: ''},
    conclusionStatement: {messages: '', responseCard: ''},
    dialogCodeHook: {uri: '', messageVersion: ''},
    fulfillmentActivity: {type: '', codeHook: ''},
    parentIntentSignature: '',
    checksum: '',
    createVersion: false,
    kendraConfiguration: {kendraIndex: '', queryFilterString: '', role: ''},
    inputContexts: [{name: ''}],
    outputContexts: [{name: '', timeToLiveInSeconds: '', turnsToLive: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/intents/:name/versions/$LATEST';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","slots":[{"name":"","description":"","slotConstraint":"","slotType":"","slotTypeVersion":"","valueElicitationPrompt":"","priority":"","sampleUtterances":"","responseCard":"","obfuscationSetting":"","defaultValueSpec":""}],"sampleUtterances":[],"confirmationPrompt":{"messages":"","maxAttempts":"","responseCard":""},"rejectionStatement":{"messages":"","responseCard":""},"followUpPrompt":{"prompt":"","rejectionStatement":""},"conclusionStatement":{"messages":"","responseCard":""},"dialogCodeHook":{"uri":"","messageVersion":""},"fulfillmentActivity":{"type":"","codeHook":""},"parentIntentSignature":"","checksum":"","createVersion":false,"kendraConfiguration":{"kendraIndex":"","queryFilterString":"","role":""},"inputContexts":[{"name":""}],"outputContexts":[{"name":"","timeToLiveInSeconds":"","turnsToLive":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"description": @"",
                              @"slots": @[ @{ @"name": @"", @"description": @"", @"slotConstraint": @"", @"slotType": @"", @"slotTypeVersion": @"", @"valueElicitationPrompt": @"", @"priority": @"", @"sampleUtterances": @"", @"responseCard": @"", @"obfuscationSetting": @"", @"defaultValueSpec": @"" } ],
                              @"sampleUtterances": @[  ],
                              @"confirmationPrompt": @{ @"messages": @"", @"maxAttempts": @"", @"responseCard": @"" },
                              @"rejectionStatement": @{ @"messages": @"", @"responseCard": @"" },
                              @"followUpPrompt": @{ @"prompt": @"", @"rejectionStatement": @"" },
                              @"conclusionStatement": @{ @"messages": @"", @"responseCard": @"" },
                              @"dialogCodeHook": @{ @"uri": @"", @"messageVersion": @"" },
                              @"fulfillmentActivity": @{ @"type": @"", @"codeHook": @"" },
                              @"parentIntentSignature": @"",
                              @"checksum": @"",
                              @"createVersion": @NO,
                              @"kendraConfiguration": @{ @"kendraIndex": @"", @"queryFilterString": @"", @"role": @"" },
                              @"inputContexts": @[ @{ @"name": @"" } ],
                              @"outputContexts": @[ @{ @"name": @"", @"timeToLiveInSeconds": @"", @"turnsToLive": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/intents/:name/versions/$LATEST"]
                                                       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}}/intents/:name/versions/$LATEST" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"description\": \"\",\n  \"slots\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"slotConstraint\": \"\",\n      \"slotType\": \"\",\n      \"slotTypeVersion\": \"\",\n      \"valueElicitationPrompt\": \"\",\n      \"priority\": \"\",\n      \"sampleUtterances\": \"\",\n      \"responseCard\": \"\",\n      \"obfuscationSetting\": \"\",\n      \"defaultValueSpec\": \"\"\n    }\n  ],\n  \"sampleUtterances\": [],\n  \"confirmationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"rejectionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"followUpPrompt\": {\n    \"prompt\": \"\",\n    \"rejectionStatement\": \"\"\n  },\n  \"conclusionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"dialogCodeHook\": {\n    \"uri\": \"\",\n    \"messageVersion\": \"\"\n  },\n  \"fulfillmentActivity\": {\n    \"type\": \"\",\n    \"codeHook\": \"\"\n  },\n  \"parentIntentSignature\": \"\",\n  \"checksum\": \"\",\n  \"createVersion\": false,\n  \"kendraConfiguration\": {\n    \"kendraIndex\": \"\",\n    \"queryFilterString\": \"\",\n    \"role\": \"\"\n  },\n  \"inputContexts\": [\n    {\n      \"name\": \"\"\n    }\n  ],\n  \"outputContexts\": [\n    {\n      \"name\": \"\",\n      \"timeToLiveInSeconds\": \"\",\n      \"turnsToLive\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/intents/:name/versions/$LATEST",
  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([
    'description' => '',
    'slots' => [
        [
                'name' => '',
                'description' => '',
                'slotConstraint' => '',
                'slotType' => '',
                'slotTypeVersion' => '',
                'valueElicitationPrompt' => '',
                'priority' => '',
                'sampleUtterances' => '',
                'responseCard' => '',
                'obfuscationSetting' => '',
                'defaultValueSpec' => ''
        ]
    ],
    'sampleUtterances' => [
        
    ],
    'confirmationPrompt' => [
        'messages' => '',
        'maxAttempts' => '',
        'responseCard' => ''
    ],
    'rejectionStatement' => [
        'messages' => '',
        'responseCard' => ''
    ],
    'followUpPrompt' => [
        'prompt' => '',
        'rejectionStatement' => ''
    ],
    'conclusionStatement' => [
        'messages' => '',
        'responseCard' => ''
    ],
    'dialogCodeHook' => [
        'uri' => '',
        'messageVersion' => ''
    ],
    'fulfillmentActivity' => [
        'type' => '',
        'codeHook' => ''
    ],
    'parentIntentSignature' => '',
    'checksum' => '',
    'createVersion' => null,
    'kendraConfiguration' => [
        'kendraIndex' => '',
        'queryFilterString' => '',
        'role' => ''
    ],
    'inputContexts' => [
        [
                'name' => ''
        ]
    ],
    'outputContexts' => [
        [
                'name' => '',
                'timeToLiveInSeconds' => '',
                'turnsToLive' => ''
        ]
    ]
  ]),
  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}}/intents/:name/versions/$LATEST', [
  'body' => '{
  "description": "",
  "slots": [
    {
      "name": "",
      "description": "",
      "slotConstraint": "",
      "slotType": "",
      "slotTypeVersion": "",
      "valueElicitationPrompt": "",
      "priority": "",
      "sampleUtterances": "",
      "responseCard": "",
      "obfuscationSetting": "",
      "defaultValueSpec": ""
    }
  ],
  "sampleUtterances": [],
  "confirmationPrompt": {
    "messages": "",
    "maxAttempts": "",
    "responseCard": ""
  },
  "rejectionStatement": {
    "messages": "",
    "responseCard": ""
  },
  "followUpPrompt": {
    "prompt": "",
    "rejectionStatement": ""
  },
  "conclusionStatement": {
    "messages": "",
    "responseCard": ""
  },
  "dialogCodeHook": {
    "uri": "",
    "messageVersion": ""
  },
  "fulfillmentActivity": {
    "type": "",
    "codeHook": ""
  },
  "parentIntentSignature": "",
  "checksum": "",
  "createVersion": false,
  "kendraConfiguration": {
    "kendraIndex": "",
    "queryFilterString": "",
    "role": ""
  },
  "inputContexts": [
    {
      "name": ""
    }
  ],
  "outputContexts": [
    {
      "name": "",
      "timeToLiveInSeconds": "",
      "turnsToLive": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/intents/:name/versions/$LATEST');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'description' => '',
  'slots' => [
    [
        'name' => '',
        'description' => '',
        'slotConstraint' => '',
        'slotType' => '',
        'slotTypeVersion' => '',
        'valueElicitationPrompt' => '',
        'priority' => '',
        'sampleUtterances' => '',
        'responseCard' => '',
        'obfuscationSetting' => '',
        'defaultValueSpec' => ''
    ]
  ],
  'sampleUtterances' => [
    
  ],
  'confirmationPrompt' => [
    'messages' => '',
    'maxAttempts' => '',
    'responseCard' => ''
  ],
  'rejectionStatement' => [
    'messages' => '',
    'responseCard' => ''
  ],
  'followUpPrompt' => [
    'prompt' => '',
    'rejectionStatement' => ''
  ],
  'conclusionStatement' => [
    'messages' => '',
    'responseCard' => ''
  ],
  'dialogCodeHook' => [
    'uri' => '',
    'messageVersion' => ''
  ],
  'fulfillmentActivity' => [
    'type' => '',
    'codeHook' => ''
  ],
  'parentIntentSignature' => '',
  'checksum' => '',
  'createVersion' => null,
  'kendraConfiguration' => [
    'kendraIndex' => '',
    'queryFilterString' => '',
    'role' => ''
  ],
  'inputContexts' => [
    [
        'name' => ''
    ]
  ],
  'outputContexts' => [
    [
        'name' => '',
        'timeToLiveInSeconds' => '',
        'turnsToLive' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'description' => '',
  'slots' => [
    [
        'name' => '',
        'description' => '',
        'slotConstraint' => '',
        'slotType' => '',
        'slotTypeVersion' => '',
        'valueElicitationPrompt' => '',
        'priority' => '',
        'sampleUtterances' => '',
        'responseCard' => '',
        'obfuscationSetting' => '',
        'defaultValueSpec' => ''
    ]
  ],
  'sampleUtterances' => [
    
  ],
  'confirmationPrompt' => [
    'messages' => '',
    'maxAttempts' => '',
    'responseCard' => ''
  ],
  'rejectionStatement' => [
    'messages' => '',
    'responseCard' => ''
  ],
  'followUpPrompt' => [
    'prompt' => '',
    'rejectionStatement' => ''
  ],
  'conclusionStatement' => [
    'messages' => '',
    'responseCard' => ''
  ],
  'dialogCodeHook' => [
    'uri' => '',
    'messageVersion' => ''
  ],
  'fulfillmentActivity' => [
    'type' => '',
    'codeHook' => ''
  ],
  'parentIntentSignature' => '',
  'checksum' => '',
  'createVersion' => null,
  'kendraConfiguration' => [
    'kendraIndex' => '',
    'queryFilterString' => '',
    'role' => ''
  ],
  'inputContexts' => [
    [
        'name' => ''
    ]
  ],
  'outputContexts' => [
    [
        'name' => '',
        'timeToLiveInSeconds' => '',
        'turnsToLive' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/intents/:name/versions/$LATEST');
$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}}/intents/:name/versions/$LATEST' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "slots": [
    {
      "name": "",
      "description": "",
      "slotConstraint": "",
      "slotType": "",
      "slotTypeVersion": "",
      "valueElicitationPrompt": "",
      "priority": "",
      "sampleUtterances": "",
      "responseCard": "",
      "obfuscationSetting": "",
      "defaultValueSpec": ""
    }
  ],
  "sampleUtterances": [],
  "confirmationPrompt": {
    "messages": "",
    "maxAttempts": "",
    "responseCard": ""
  },
  "rejectionStatement": {
    "messages": "",
    "responseCard": ""
  },
  "followUpPrompt": {
    "prompt": "",
    "rejectionStatement": ""
  },
  "conclusionStatement": {
    "messages": "",
    "responseCard": ""
  },
  "dialogCodeHook": {
    "uri": "",
    "messageVersion": ""
  },
  "fulfillmentActivity": {
    "type": "",
    "codeHook": ""
  },
  "parentIntentSignature": "",
  "checksum": "",
  "createVersion": false,
  "kendraConfiguration": {
    "kendraIndex": "",
    "queryFilterString": "",
    "role": ""
  },
  "inputContexts": [
    {
      "name": ""
    }
  ],
  "outputContexts": [
    {
      "name": "",
      "timeToLiveInSeconds": "",
      "turnsToLive": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/intents/:name/versions/$LATEST' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "slots": [
    {
      "name": "",
      "description": "",
      "slotConstraint": "",
      "slotType": "",
      "slotTypeVersion": "",
      "valueElicitationPrompt": "",
      "priority": "",
      "sampleUtterances": "",
      "responseCard": "",
      "obfuscationSetting": "",
      "defaultValueSpec": ""
    }
  ],
  "sampleUtterances": [],
  "confirmationPrompt": {
    "messages": "",
    "maxAttempts": "",
    "responseCard": ""
  },
  "rejectionStatement": {
    "messages": "",
    "responseCard": ""
  },
  "followUpPrompt": {
    "prompt": "",
    "rejectionStatement": ""
  },
  "conclusionStatement": {
    "messages": "",
    "responseCard": ""
  },
  "dialogCodeHook": {
    "uri": "",
    "messageVersion": ""
  },
  "fulfillmentActivity": {
    "type": "",
    "codeHook": ""
  },
  "parentIntentSignature": "",
  "checksum": "",
  "createVersion": false,
  "kendraConfiguration": {
    "kendraIndex": "",
    "queryFilterString": "",
    "role": ""
  },
  "inputContexts": [
    {
      "name": ""
    }
  ],
  "outputContexts": [
    {
      "name": "",
      "timeToLiveInSeconds": "",
      "turnsToLive": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"description\": \"\",\n  \"slots\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"slotConstraint\": \"\",\n      \"slotType\": \"\",\n      \"slotTypeVersion\": \"\",\n      \"valueElicitationPrompt\": \"\",\n      \"priority\": \"\",\n      \"sampleUtterances\": \"\",\n      \"responseCard\": \"\",\n      \"obfuscationSetting\": \"\",\n      \"defaultValueSpec\": \"\"\n    }\n  ],\n  \"sampleUtterances\": [],\n  \"confirmationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"rejectionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"followUpPrompt\": {\n    \"prompt\": \"\",\n    \"rejectionStatement\": \"\"\n  },\n  \"conclusionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"dialogCodeHook\": {\n    \"uri\": \"\",\n    \"messageVersion\": \"\"\n  },\n  \"fulfillmentActivity\": {\n    \"type\": \"\",\n    \"codeHook\": \"\"\n  },\n  \"parentIntentSignature\": \"\",\n  \"checksum\": \"\",\n  \"createVersion\": false,\n  \"kendraConfiguration\": {\n    \"kendraIndex\": \"\",\n    \"queryFilterString\": \"\",\n    \"role\": \"\"\n  },\n  \"inputContexts\": [\n    {\n      \"name\": \"\"\n    }\n  ],\n  \"outputContexts\": [\n    {\n      \"name\": \"\",\n      \"timeToLiveInSeconds\": \"\",\n      \"turnsToLive\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/intents/:name/versions/$LATEST", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/intents/:name/versions/$LATEST"

payload = {
    "description": "",
    "slots": [
        {
            "name": "",
            "description": "",
            "slotConstraint": "",
            "slotType": "",
            "slotTypeVersion": "",
            "valueElicitationPrompt": "",
            "priority": "",
            "sampleUtterances": "",
            "responseCard": "",
            "obfuscationSetting": "",
            "defaultValueSpec": ""
        }
    ],
    "sampleUtterances": [],
    "confirmationPrompt": {
        "messages": "",
        "maxAttempts": "",
        "responseCard": ""
    },
    "rejectionStatement": {
        "messages": "",
        "responseCard": ""
    },
    "followUpPrompt": {
        "prompt": "",
        "rejectionStatement": ""
    },
    "conclusionStatement": {
        "messages": "",
        "responseCard": ""
    },
    "dialogCodeHook": {
        "uri": "",
        "messageVersion": ""
    },
    "fulfillmentActivity": {
        "type": "",
        "codeHook": ""
    },
    "parentIntentSignature": "",
    "checksum": "",
    "createVersion": False,
    "kendraConfiguration": {
        "kendraIndex": "",
        "queryFilterString": "",
        "role": ""
    },
    "inputContexts": [{ "name": "" }],
    "outputContexts": [
        {
            "name": "",
            "timeToLiveInSeconds": "",
            "turnsToLive": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/intents/:name/versions/$LATEST"

payload <- "{\n  \"description\": \"\",\n  \"slots\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"slotConstraint\": \"\",\n      \"slotType\": \"\",\n      \"slotTypeVersion\": \"\",\n      \"valueElicitationPrompt\": \"\",\n      \"priority\": \"\",\n      \"sampleUtterances\": \"\",\n      \"responseCard\": \"\",\n      \"obfuscationSetting\": \"\",\n      \"defaultValueSpec\": \"\"\n    }\n  ],\n  \"sampleUtterances\": [],\n  \"confirmationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"rejectionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"followUpPrompt\": {\n    \"prompt\": \"\",\n    \"rejectionStatement\": \"\"\n  },\n  \"conclusionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"dialogCodeHook\": {\n    \"uri\": \"\",\n    \"messageVersion\": \"\"\n  },\n  \"fulfillmentActivity\": {\n    \"type\": \"\",\n    \"codeHook\": \"\"\n  },\n  \"parentIntentSignature\": \"\",\n  \"checksum\": \"\",\n  \"createVersion\": false,\n  \"kendraConfiguration\": {\n    \"kendraIndex\": \"\",\n    \"queryFilterString\": \"\",\n    \"role\": \"\"\n  },\n  \"inputContexts\": [\n    {\n      \"name\": \"\"\n    }\n  ],\n  \"outputContexts\": [\n    {\n      \"name\": \"\",\n      \"timeToLiveInSeconds\": \"\",\n      \"turnsToLive\": \"\"\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}}/intents/:name/versions/$LATEST")

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  \"description\": \"\",\n  \"slots\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"slotConstraint\": \"\",\n      \"slotType\": \"\",\n      \"slotTypeVersion\": \"\",\n      \"valueElicitationPrompt\": \"\",\n      \"priority\": \"\",\n      \"sampleUtterances\": \"\",\n      \"responseCard\": \"\",\n      \"obfuscationSetting\": \"\",\n      \"defaultValueSpec\": \"\"\n    }\n  ],\n  \"sampleUtterances\": [],\n  \"confirmationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"rejectionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"followUpPrompt\": {\n    \"prompt\": \"\",\n    \"rejectionStatement\": \"\"\n  },\n  \"conclusionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"dialogCodeHook\": {\n    \"uri\": \"\",\n    \"messageVersion\": \"\"\n  },\n  \"fulfillmentActivity\": {\n    \"type\": \"\",\n    \"codeHook\": \"\"\n  },\n  \"parentIntentSignature\": \"\",\n  \"checksum\": \"\",\n  \"createVersion\": false,\n  \"kendraConfiguration\": {\n    \"kendraIndex\": \"\",\n    \"queryFilterString\": \"\",\n    \"role\": \"\"\n  },\n  \"inputContexts\": [\n    {\n      \"name\": \"\"\n    }\n  ],\n  \"outputContexts\": [\n    {\n      \"name\": \"\",\n      \"timeToLiveInSeconds\": \"\",\n      \"turnsToLive\": \"\"\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/intents/:name/versions/$LATEST') do |req|
  req.body = "{\n  \"description\": \"\",\n  \"slots\": [\n    {\n      \"name\": \"\",\n      \"description\": \"\",\n      \"slotConstraint\": \"\",\n      \"slotType\": \"\",\n      \"slotTypeVersion\": \"\",\n      \"valueElicitationPrompt\": \"\",\n      \"priority\": \"\",\n      \"sampleUtterances\": \"\",\n      \"responseCard\": \"\",\n      \"obfuscationSetting\": \"\",\n      \"defaultValueSpec\": \"\"\n    }\n  ],\n  \"sampleUtterances\": [],\n  \"confirmationPrompt\": {\n    \"messages\": \"\",\n    \"maxAttempts\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"rejectionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"followUpPrompt\": {\n    \"prompt\": \"\",\n    \"rejectionStatement\": \"\"\n  },\n  \"conclusionStatement\": {\n    \"messages\": \"\",\n    \"responseCard\": \"\"\n  },\n  \"dialogCodeHook\": {\n    \"uri\": \"\",\n    \"messageVersion\": \"\"\n  },\n  \"fulfillmentActivity\": {\n    \"type\": \"\",\n    \"codeHook\": \"\"\n  },\n  \"parentIntentSignature\": \"\",\n  \"checksum\": \"\",\n  \"createVersion\": false,\n  \"kendraConfiguration\": {\n    \"kendraIndex\": \"\",\n    \"queryFilterString\": \"\",\n    \"role\": \"\"\n  },\n  \"inputContexts\": [\n    {\n      \"name\": \"\"\n    }\n  ],\n  \"outputContexts\": [\n    {\n      \"name\": \"\",\n      \"timeToLiveInSeconds\": \"\",\n      \"turnsToLive\": \"\"\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}}/intents/:name/versions/$LATEST";

    let payload = json!({
        "description": "",
        "slots": (
            json!({
                "name": "",
                "description": "",
                "slotConstraint": "",
                "slotType": "",
                "slotTypeVersion": "",
                "valueElicitationPrompt": "",
                "priority": "",
                "sampleUtterances": "",
                "responseCard": "",
                "obfuscationSetting": "",
                "defaultValueSpec": ""
            })
        ),
        "sampleUtterances": (),
        "confirmationPrompt": json!({
            "messages": "",
            "maxAttempts": "",
            "responseCard": ""
        }),
        "rejectionStatement": json!({
            "messages": "",
            "responseCard": ""
        }),
        "followUpPrompt": json!({
            "prompt": "",
            "rejectionStatement": ""
        }),
        "conclusionStatement": json!({
            "messages": "",
            "responseCard": ""
        }),
        "dialogCodeHook": json!({
            "uri": "",
            "messageVersion": ""
        }),
        "fulfillmentActivity": json!({
            "type": "",
            "codeHook": ""
        }),
        "parentIntentSignature": "",
        "checksum": "",
        "createVersion": false,
        "kendraConfiguration": json!({
            "kendraIndex": "",
            "queryFilterString": "",
            "role": ""
        }),
        "inputContexts": (json!({"name": ""})),
        "outputContexts": (
            json!({
                "name": "",
                "timeToLiveInSeconds": "",
                "turnsToLive": ""
            })
        )
    });

    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 '{
  "description": "",
  "slots": [
    {
      "name": "",
      "description": "",
      "slotConstraint": "",
      "slotType": "",
      "slotTypeVersion": "",
      "valueElicitationPrompt": "",
      "priority": "",
      "sampleUtterances": "",
      "responseCard": "",
      "obfuscationSetting": "",
      "defaultValueSpec": ""
    }
  ],
  "sampleUtterances": [],
  "confirmationPrompt": {
    "messages": "",
    "maxAttempts": "",
    "responseCard": ""
  },
  "rejectionStatement": {
    "messages": "",
    "responseCard": ""
  },
  "followUpPrompt": {
    "prompt": "",
    "rejectionStatement": ""
  },
  "conclusionStatement": {
    "messages": "",
    "responseCard": ""
  },
  "dialogCodeHook": {
    "uri": "",
    "messageVersion": ""
  },
  "fulfillmentActivity": {
    "type": "",
    "codeHook": ""
  },
  "parentIntentSignature": "",
  "checksum": "",
  "createVersion": false,
  "kendraConfiguration": {
    "kendraIndex": "",
    "queryFilterString": "",
    "role": ""
  },
  "inputContexts": [
    {
      "name": ""
    }
  ],
  "outputContexts": [
    {
      "name": "",
      "timeToLiveInSeconds": "",
      "turnsToLive": ""
    }
  ]
}' |  \
  http PUT '{{baseUrl}}/intents/:name/versions/$LATEST' \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "description": "",\n  "slots": [\n    {\n      "name": "",\n      "description": "",\n      "slotConstraint": "",\n      "slotType": "",\n      "slotTypeVersion": "",\n      "valueElicitationPrompt": "",\n      "priority": "",\n      "sampleUtterances": "",\n      "responseCard": "",\n      "obfuscationSetting": "",\n      "defaultValueSpec": ""\n    }\n  ],\n  "sampleUtterances": [],\n  "confirmationPrompt": {\n    "messages": "",\n    "maxAttempts": "",\n    "responseCard": ""\n  },\n  "rejectionStatement": {\n    "messages": "",\n    "responseCard": ""\n  },\n  "followUpPrompt": {\n    "prompt": "",\n    "rejectionStatement": ""\n  },\n  "conclusionStatement": {\n    "messages": "",\n    "responseCard": ""\n  },\n  "dialogCodeHook": {\n    "uri": "",\n    "messageVersion": ""\n  },\n  "fulfillmentActivity": {\n    "type": "",\n    "codeHook": ""\n  },\n  "parentIntentSignature": "",\n  "checksum": "",\n  "createVersion": false,\n  "kendraConfiguration": {\n    "kendraIndex": "",\n    "queryFilterString": "",\n    "role": ""\n  },\n  "inputContexts": [\n    {\n      "name": ""\n    }\n  ],\n  "outputContexts": [\n    {\n      "name": "",\n      "timeToLiveInSeconds": "",\n      "turnsToLive": ""\n    }\n  ]\n}' \
  --output-document \
  - '{{baseUrl}}/intents/:name/versions/$LATEST'

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "description": "",
  "slots": [
    [
      "name": "",
      "description": "",
      "slotConstraint": "",
      "slotType": "",
      "slotTypeVersion": "",
      "valueElicitationPrompt": "",
      "priority": "",
      "sampleUtterances": "",
      "responseCard": "",
      "obfuscationSetting": "",
      "defaultValueSpec": ""
    ]
  ],
  "sampleUtterances": [],
  "confirmationPrompt": [
    "messages": "",
    "maxAttempts": "",
    "responseCard": ""
  ],
  "rejectionStatement": [
    "messages": "",
    "responseCard": ""
  ],
  "followUpPrompt": [
    "prompt": "",
    "rejectionStatement": ""
  ],
  "conclusionStatement": [
    "messages": "",
    "responseCard": ""
  ],
  "dialogCodeHook": [
    "uri": "",
    "messageVersion": ""
  ],
  "fulfillmentActivity": [
    "type": "",
    "codeHook": ""
  ],
  "parentIntentSignature": "",
  "checksum": "",
  "createVersion": false,
  "kendraConfiguration": [
    "kendraIndex": "",
    "queryFilterString": "",
    "role": ""
  ],
  "inputContexts": [["name": ""]],
  "outputContexts": [
    [
      "name": "",
      "timeToLiveInSeconds": "",
      "turnsToLive": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/intents/:name/versions/$LATEST")! 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}}/slottypes/:name/versions/$LATEST");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"description\": \"\",\n  \"enumerationValues\": [\n    {\n      \"value\": \"\",\n      \"synonyms\": \"\"\n    }\n  ],\n  \"checksum\": \"\",\n  \"valueSelectionStrategy\": \"\",\n  \"createVersion\": false,\n  \"parentSlotTypeSignature\": \"\",\n  \"slotTypeConfigurations\": [\n    {\n      \"regexConfiguration\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/slottypes/:name/versions/$LATEST" {:content-type :json
                                                                            :form-params {:description ""
                                                                                          :enumerationValues [{:value ""
                                                                                                               :synonyms ""}]
                                                                                          :checksum ""
                                                                                          :valueSelectionStrategy ""
                                                                                          :createVersion false
                                                                                          :parentSlotTypeSignature ""
                                                                                          :slotTypeConfigurations [{:regexConfiguration ""}]}})

require "http/client"

url = "{{baseUrl}}/slottypes/:name/versions/$LATEST"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"description\": \"\",\n  \"enumerationValues\": [\n    {\n      \"value\": \"\",\n      \"synonyms\": \"\"\n    }\n  ],\n  \"checksum\": \"\",\n  \"valueSelectionStrategy\": \"\",\n  \"createVersion\": false,\n  \"parentSlotTypeSignature\": \"\",\n  \"slotTypeConfigurations\": [\n    {\n      \"regexConfiguration\": \"\"\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}}/slottypes/:name/versions/$LATEST"),
    Content = new StringContent("{\n  \"description\": \"\",\n  \"enumerationValues\": [\n    {\n      \"value\": \"\",\n      \"synonyms\": \"\"\n    }\n  ],\n  \"checksum\": \"\",\n  \"valueSelectionStrategy\": \"\",\n  \"createVersion\": false,\n  \"parentSlotTypeSignature\": \"\",\n  \"slotTypeConfigurations\": [\n    {\n      \"regexConfiguration\": \"\"\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}}/slottypes/:name/versions/$LATEST");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"description\": \"\",\n  \"enumerationValues\": [\n    {\n      \"value\": \"\",\n      \"synonyms\": \"\"\n    }\n  ],\n  \"checksum\": \"\",\n  \"valueSelectionStrategy\": \"\",\n  \"createVersion\": false,\n  \"parentSlotTypeSignature\": \"\",\n  \"slotTypeConfigurations\": [\n    {\n      \"regexConfiguration\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/slottypes/:name/versions/$LATEST"

	payload := strings.NewReader("{\n  \"description\": \"\",\n  \"enumerationValues\": [\n    {\n      \"value\": \"\",\n      \"synonyms\": \"\"\n    }\n  ],\n  \"checksum\": \"\",\n  \"valueSelectionStrategy\": \"\",\n  \"createVersion\": false,\n  \"parentSlotTypeSignature\": \"\",\n  \"slotTypeConfigurations\": [\n    {\n      \"regexConfiguration\": \"\"\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/slottypes/:name/versions/$LATEST HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 292

{
  "description": "",
  "enumerationValues": [
    {
      "value": "",
      "synonyms": ""
    }
  ],
  "checksum": "",
  "valueSelectionStrategy": "",
  "createVersion": false,
  "parentSlotTypeSignature": "",
  "slotTypeConfigurations": [
    {
      "regexConfiguration": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/slottypes/:name/versions/$LATEST")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"description\": \"\",\n  \"enumerationValues\": [\n    {\n      \"value\": \"\",\n      \"synonyms\": \"\"\n    }\n  ],\n  \"checksum\": \"\",\n  \"valueSelectionStrategy\": \"\",\n  \"createVersion\": false,\n  \"parentSlotTypeSignature\": \"\",\n  \"slotTypeConfigurations\": [\n    {\n      \"regexConfiguration\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/slottypes/:name/versions/$LATEST"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"description\": \"\",\n  \"enumerationValues\": [\n    {\n      \"value\": \"\",\n      \"synonyms\": \"\"\n    }\n  ],\n  \"checksum\": \"\",\n  \"valueSelectionStrategy\": \"\",\n  \"createVersion\": false,\n  \"parentSlotTypeSignature\": \"\",\n  \"slotTypeConfigurations\": [\n    {\n      \"regexConfiguration\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"enumerationValues\": [\n    {\n      \"value\": \"\",\n      \"synonyms\": \"\"\n    }\n  ],\n  \"checksum\": \"\",\n  \"valueSelectionStrategy\": \"\",\n  \"createVersion\": false,\n  \"parentSlotTypeSignature\": \"\",\n  \"slotTypeConfigurations\": [\n    {\n      \"regexConfiguration\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/slottypes/:name/versions/$LATEST")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/slottypes/:name/versions/$LATEST")
  .header("content-type", "application/json")
  .body("{\n  \"description\": \"\",\n  \"enumerationValues\": [\n    {\n      \"value\": \"\",\n      \"synonyms\": \"\"\n    }\n  ],\n  \"checksum\": \"\",\n  \"valueSelectionStrategy\": \"\",\n  \"createVersion\": false,\n  \"parentSlotTypeSignature\": \"\",\n  \"slotTypeConfigurations\": [\n    {\n      \"regexConfiguration\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  description: '',
  enumerationValues: [
    {
      value: '',
      synonyms: ''
    }
  ],
  checksum: '',
  valueSelectionStrategy: '',
  createVersion: false,
  parentSlotTypeSignature: '',
  slotTypeConfigurations: [
    {
      regexConfiguration: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/slottypes/:name/versions/$LATEST');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/slottypes/:name/versions/$LATEST',
  headers: {'content-type': 'application/json'},
  data: {
    description: '',
    enumerationValues: [{value: '', synonyms: ''}],
    checksum: '',
    valueSelectionStrategy: '',
    createVersion: false,
    parentSlotTypeSignature: '',
    slotTypeConfigurations: [{regexConfiguration: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/slottypes/:name/versions/$LATEST';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","enumerationValues":[{"value":"","synonyms":""}],"checksum":"","valueSelectionStrategy":"","createVersion":false,"parentSlotTypeSignature":"","slotTypeConfigurations":[{"regexConfiguration":""}]}'
};

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}}/slottypes/:name/versions/$LATEST',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "description": "",\n  "enumerationValues": [\n    {\n      "value": "",\n      "synonyms": ""\n    }\n  ],\n  "checksum": "",\n  "valueSelectionStrategy": "",\n  "createVersion": false,\n  "parentSlotTypeSignature": "",\n  "slotTypeConfigurations": [\n    {\n      "regexConfiguration": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"enumerationValues\": [\n    {\n      \"value\": \"\",\n      \"synonyms\": \"\"\n    }\n  ],\n  \"checksum\": \"\",\n  \"valueSelectionStrategy\": \"\",\n  \"createVersion\": false,\n  \"parentSlotTypeSignature\": \"\",\n  \"slotTypeConfigurations\": [\n    {\n      \"regexConfiguration\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/slottypes/:name/versions/$LATEST")
  .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/slottypes/:name/versions/$LATEST',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  description: '',
  enumerationValues: [{value: '', synonyms: ''}],
  checksum: '',
  valueSelectionStrategy: '',
  createVersion: false,
  parentSlotTypeSignature: '',
  slotTypeConfigurations: [{regexConfiguration: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/slottypes/:name/versions/$LATEST',
  headers: {'content-type': 'application/json'},
  body: {
    description: '',
    enumerationValues: [{value: '', synonyms: ''}],
    checksum: '',
    valueSelectionStrategy: '',
    createVersion: false,
    parentSlotTypeSignature: '',
    slotTypeConfigurations: [{regexConfiguration: ''}]
  },
  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}}/slottypes/:name/versions/$LATEST');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  description: '',
  enumerationValues: [
    {
      value: '',
      synonyms: ''
    }
  ],
  checksum: '',
  valueSelectionStrategy: '',
  createVersion: false,
  parentSlotTypeSignature: '',
  slotTypeConfigurations: [
    {
      regexConfiguration: ''
    }
  ]
});

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}}/slottypes/:name/versions/$LATEST',
  headers: {'content-type': 'application/json'},
  data: {
    description: '',
    enumerationValues: [{value: '', synonyms: ''}],
    checksum: '',
    valueSelectionStrategy: '',
    createVersion: false,
    parentSlotTypeSignature: '',
    slotTypeConfigurations: [{regexConfiguration: ''}]
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/slottypes/:name/versions/$LATEST';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"description":"","enumerationValues":[{"value":"","synonyms":""}],"checksum":"","valueSelectionStrategy":"","createVersion":false,"parentSlotTypeSignature":"","slotTypeConfigurations":[{"regexConfiguration":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"description": @"",
                              @"enumerationValues": @[ @{ @"value": @"", @"synonyms": @"" } ],
                              @"checksum": @"",
                              @"valueSelectionStrategy": @"",
                              @"createVersion": @NO,
                              @"parentSlotTypeSignature": @"",
                              @"slotTypeConfigurations": @[ @{ @"regexConfiguration": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/slottypes/:name/versions/$LATEST"]
                                                       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}}/slottypes/:name/versions/$LATEST" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"description\": \"\",\n  \"enumerationValues\": [\n    {\n      \"value\": \"\",\n      \"synonyms\": \"\"\n    }\n  ],\n  \"checksum\": \"\",\n  \"valueSelectionStrategy\": \"\",\n  \"createVersion\": false,\n  \"parentSlotTypeSignature\": \"\",\n  \"slotTypeConfigurations\": [\n    {\n      \"regexConfiguration\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/slottypes/:name/versions/$LATEST",
  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([
    'description' => '',
    'enumerationValues' => [
        [
                'value' => '',
                'synonyms' => ''
        ]
    ],
    'checksum' => '',
    'valueSelectionStrategy' => '',
    'createVersion' => null,
    'parentSlotTypeSignature' => '',
    'slotTypeConfigurations' => [
        [
                'regexConfiguration' => ''
        ]
    ]
  ]),
  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}}/slottypes/:name/versions/$LATEST', [
  'body' => '{
  "description": "",
  "enumerationValues": [
    {
      "value": "",
      "synonyms": ""
    }
  ],
  "checksum": "",
  "valueSelectionStrategy": "",
  "createVersion": false,
  "parentSlotTypeSignature": "",
  "slotTypeConfigurations": [
    {
      "regexConfiguration": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/slottypes/:name/versions/$LATEST');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'description' => '',
  'enumerationValues' => [
    [
        'value' => '',
        'synonyms' => ''
    ]
  ],
  'checksum' => '',
  'valueSelectionStrategy' => '',
  'createVersion' => null,
  'parentSlotTypeSignature' => '',
  'slotTypeConfigurations' => [
    [
        'regexConfiguration' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'description' => '',
  'enumerationValues' => [
    [
        'value' => '',
        'synonyms' => ''
    ]
  ],
  'checksum' => '',
  'valueSelectionStrategy' => '',
  'createVersion' => null,
  'parentSlotTypeSignature' => '',
  'slotTypeConfigurations' => [
    [
        'regexConfiguration' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/slottypes/:name/versions/$LATEST');
$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}}/slottypes/:name/versions/$LATEST' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "enumerationValues": [
    {
      "value": "",
      "synonyms": ""
    }
  ],
  "checksum": "",
  "valueSelectionStrategy": "",
  "createVersion": false,
  "parentSlotTypeSignature": "",
  "slotTypeConfigurations": [
    {
      "regexConfiguration": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/slottypes/:name/versions/$LATEST' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "enumerationValues": [
    {
      "value": "",
      "synonyms": ""
    }
  ],
  "checksum": "",
  "valueSelectionStrategy": "",
  "createVersion": false,
  "parentSlotTypeSignature": "",
  "slotTypeConfigurations": [
    {
      "regexConfiguration": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"description\": \"\",\n  \"enumerationValues\": [\n    {\n      \"value\": \"\",\n      \"synonyms\": \"\"\n    }\n  ],\n  \"checksum\": \"\",\n  \"valueSelectionStrategy\": \"\",\n  \"createVersion\": false,\n  \"parentSlotTypeSignature\": \"\",\n  \"slotTypeConfigurations\": [\n    {\n      \"regexConfiguration\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/slottypes/:name/versions/$LATEST", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/slottypes/:name/versions/$LATEST"

payload = {
    "description": "",
    "enumerationValues": [
        {
            "value": "",
            "synonyms": ""
        }
    ],
    "checksum": "",
    "valueSelectionStrategy": "",
    "createVersion": False,
    "parentSlotTypeSignature": "",
    "slotTypeConfigurations": [{ "regexConfiguration": "" }]
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/slottypes/:name/versions/$LATEST"

payload <- "{\n  \"description\": \"\",\n  \"enumerationValues\": [\n    {\n      \"value\": \"\",\n      \"synonyms\": \"\"\n    }\n  ],\n  \"checksum\": \"\",\n  \"valueSelectionStrategy\": \"\",\n  \"createVersion\": false,\n  \"parentSlotTypeSignature\": \"\",\n  \"slotTypeConfigurations\": [\n    {\n      \"regexConfiguration\": \"\"\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}}/slottypes/:name/versions/$LATEST")

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  \"description\": \"\",\n  \"enumerationValues\": [\n    {\n      \"value\": \"\",\n      \"synonyms\": \"\"\n    }\n  ],\n  \"checksum\": \"\",\n  \"valueSelectionStrategy\": \"\",\n  \"createVersion\": false,\n  \"parentSlotTypeSignature\": \"\",\n  \"slotTypeConfigurations\": [\n    {\n      \"regexConfiguration\": \"\"\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/slottypes/:name/versions/$LATEST') do |req|
  req.body = "{\n  \"description\": \"\",\n  \"enumerationValues\": [\n    {\n      \"value\": \"\",\n      \"synonyms\": \"\"\n    }\n  ],\n  \"checksum\": \"\",\n  \"valueSelectionStrategy\": \"\",\n  \"createVersion\": false,\n  \"parentSlotTypeSignature\": \"\",\n  \"slotTypeConfigurations\": [\n    {\n      \"regexConfiguration\": \"\"\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}}/slottypes/:name/versions/$LATEST";

    let payload = json!({
        "description": "",
        "enumerationValues": (
            json!({
                "value": "",
                "synonyms": ""
            })
        ),
        "checksum": "",
        "valueSelectionStrategy": "",
        "createVersion": false,
        "parentSlotTypeSignature": "",
        "slotTypeConfigurations": (json!({"regexConfiguration": ""}))
    });

    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 '{
  "description": "",
  "enumerationValues": [
    {
      "value": "",
      "synonyms": ""
    }
  ],
  "checksum": "",
  "valueSelectionStrategy": "",
  "createVersion": false,
  "parentSlotTypeSignature": "",
  "slotTypeConfigurations": [
    {
      "regexConfiguration": ""
    }
  ]
}' |  \
  http PUT '{{baseUrl}}/slottypes/:name/versions/$LATEST' \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "description": "",\n  "enumerationValues": [\n    {\n      "value": "",\n      "synonyms": ""\n    }\n  ],\n  "checksum": "",\n  "valueSelectionStrategy": "",\n  "createVersion": false,\n  "parentSlotTypeSignature": "",\n  "slotTypeConfigurations": [\n    {\n      "regexConfiguration": ""\n    }\n  ]\n}' \
  --output-document \
  - '{{baseUrl}}/slottypes/:name/versions/$LATEST'

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "description": "",
  "enumerationValues": [
    [
      "value": "",
      "synonyms": ""
    ]
  ],
  "checksum": "",
  "valueSelectionStrategy": "",
  "createVersion": false,
  "parentSlotTypeSignature": "",
  "slotTypeConfigurations": [["regexConfiguration": ""]]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/slottypes/:name/versions/$LATEST")! 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}}/imports/");

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  \"payload\": \"\",\n  \"resourceType\": \"\",\n  \"mergeStrategy\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/imports/" {:content-type :json
                                                     :form-params {:payload ""
                                                                   :resourceType ""
                                                                   :mergeStrategy ""
                                                                   :tags [{:key ""
                                                                           :value ""}]}})

require "http/client"

url = "{{baseUrl}}/imports/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"payload\": \"\",\n  \"resourceType\": \"\",\n  \"mergeStrategy\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/imports/"),
    Content = new StringContent("{\n  \"payload\": \"\",\n  \"resourceType\": \"\",\n  \"mergeStrategy\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/imports/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"payload\": \"\",\n  \"resourceType\": \"\",\n  \"mergeStrategy\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/imports/"

	payload := strings.NewReader("{\n  \"payload\": \"\",\n  \"resourceType\": \"\",\n  \"mergeStrategy\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/imports/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 128

{
  "payload": "",
  "resourceType": "",
  "mergeStrategy": "",
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/imports/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"payload\": \"\",\n  \"resourceType\": \"\",\n  \"mergeStrategy\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/imports/"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"payload\": \"\",\n  \"resourceType\": \"\",\n  \"mergeStrategy\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"payload\": \"\",\n  \"resourceType\": \"\",\n  \"mergeStrategy\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/imports/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/imports/")
  .header("content-type", "application/json")
  .body("{\n  \"payload\": \"\",\n  \"resourceType\": \"\",\n  \"mergeStrategy\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  payload: '',
  resourceType: '',
  mergeStrategy: '',
  tags: [
    {
      key: '',
      value: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/imports/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/imports/',
  headers: {'content-type': 'application/json'},
  data: {payload: '', resourceType: '', mergeStrategy: '', tags: [{key: '', value: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/imports/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"payload":"","resourceType":"","mergeStrategy":"","tags":[{"key":"","value":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/imports/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "payload": "",\n  "resourceType": "",\n  "mergeStrategy": "",\n  "tags": [\n    {\n      "key": "",\n      "value": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"payload\": \"\",\n  \"resourceType\": \"\",\n  \"mergeStrategy\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/imports/")
  .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/imports/',
  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({payload: '', resourceType: '', mergeStrategy: '', tags: [{key: '', value: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/imports/',
  headers: {'content-type': 'application/json'},
  body: {payload: '', resourceType: '', mergeStrategy: '', tags: [{key: '', value: ''}]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/imports/');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  payload: '',
  resourceType: '',
  mergeStrategy: '',
  tags: [
    {
      key: '',
      value: ''
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/imports/',
  headers: {'content-type': 'application/json'},
  data: {payload: '', resourceType: '', mergeStrategy: '', tags: [{key: '', value: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/imports/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"payload":"","resourceType":"","mergeStrategy":"","tags":[{"key":"","value":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"payload": @"",
                              @"resourceType": @"",
                              @"mergeStrategy": @"",
                              @"tags": @[ @{ @"key": @"", @"value": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/imports/"]
                                                       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}}/imports/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"payload\": \"\",\n  \"resourceType\": \"\",\n  \"mergeStrategy\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/imports/",
  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([
    'payload' => '',
    'resourceType' => '',
    'mergeStrategy' => '',
    'tags' => [
        [
                'key' => '',
                'value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/imports/', [
  'body' => '{
  "payload": "",
  "resourceType": "",
  "mergeStrategy": "",
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/imports/');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'payload' => '',
  'resourceType' => '',
  'mergeStrategy' => '',
  'tags' => [
    [
        'key' => '',
        'value' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'payload' => '',
  'resourceType' => '',
  'mergeStrategy' => '',
  'tags' => [
    [
        'key' => '',
        'value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/imports/');
$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}}/imports/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "payload": "",
  "resourceType": "",
  "mergeStrategy": "",
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/imports/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "payload": "",
  "resourceType": "",
  "mergeStrategy": "",
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"payload\": \"\",\n  \"resourceType\": \"\",\n  \"mergeStrategy\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/imports/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/imports/"

payload = {
    "payload": "",
    "resourceType": "",
    "mergeStrategy": "",
    "tags": [
        {
            "key": "",
            "value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/imports/"

payload <- "{\n  \"payload\": \"\",\n  \"resourceType\": \"\",\n  \"mergeStrategy\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/imports/")

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  \"payload\": \"\",\n  \"resourceType\": \"\",\n  \"mergeStrategy\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/imports/') do |req|
  req.body = "{\n  \"payload\": \"\",\n  \"resourceType\": \"\",\n  \"mergeStrategy\": \"\",\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/imports/";

    let payload = json!({
        "payload": "",
        "resourceType": "",
        "mergeStrategy": "",
        "tags": (
            json!({
                "key": "",
                "value": ""
            })
        )
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "payload": "",
  "resourceType": "",
  "mergeStrategy": "",
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/imports/ \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "payload": "",\n  "resourceType": "",\n  "mergeStrategy": "",\n  "tags": [\n    {\n      "key": "",\n      "value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/imports/

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "payload": "",
  "resourceType": "",
  "mergeStrategy": "",
  "tags": [
    [
      "key": "",
      "value": ""
    ]
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/imports/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/migrations");

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  \"v1BotName\": \"\",\n  \"v1BotVersion\": \"\",\n  \"v2BotName\": \"\",\n  \"v2BotRole\": \"\",\n  \"migrationStrategy\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/migrations" {:content-type :json
                                                       :form-params {:v1BotName ""
                                                                     :v1BotVersion ""
                                                                     :v2BotName ""
                                                                     :v2BotRole ""
                                                                     :migrationStrategy ""}})

require "http/client"

url = "{{baseUrl}}/migrations"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"v1BotName\": \"\",\n  \"v1BotVersion\": \"\",\n  \"v2BotName\": \"\",\n  \"v2BotRole\": \"\",\n  \"migrationStrategy\": \"\"\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}}/migrations"),
    Content = new StringContent("{\n  \"v1BotName\": \"\",\n  \"v1BotVersion\": \"\",\n  \"v2BotName\": \"\",\n  \"v2BotRole\": \"\",\n  \"migrationStrategy\": \"\"\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}}/migrations");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"v1BotName\": \"\",\n  \"v1BotVersion\": \"\",\n  \"v2BotName\": \"\",\n  \"v2BotRole\": \"\",\n  \"migrationStrategy\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/migrations"

	payload := strings.NewReader("{\n  \"v1BotName\": \"\",\n  \"v1BotVersion\": \"\",\n  \"v2BotName\": \"\",\n  \"v2BotRole\": \"\",\n  \"migrationStrategy\": \"\"\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/migrations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 108

{
  "v1BotName": "",
  "v1BotVersion": "",
  "v2BotName": "",
  "v2BotRole": "",
  "migrationStrategy": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/migrations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"v1BotName\": \"\",\n  \"v1BotVersion\": \"\",\n  \"v2BotName\": \"\",\n  \"v2BotRole\": \"\",\n  \"migrationStrategy\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/migrations"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"v1BotName\": \"\",\n  \"v1BotVersion\": \"\",\n  \"v2BotName\": \"\",\n  \"v2BotRole\": \"\",\n  \"migrationStrategy\": \"\"\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  \"v1BotName\": \"\",\n  \"v1BotVersion\": \"\",\n  \"v2BotName\": \"\",\n  \"v2BotRole\": \"\",\n  \"migrationStrategy\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/migrations")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/migrations")
  .header("content-type", "application/json")
  .body("{\n  \"v1BotName\": \"\",\n  \"v1BotVersion\": \"\",\n  \"v2BotName\": \"\",\n  \"v2BotRole\": \"\",\n  \"migrationStrategy\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  v1BotName: '',
  v1BotVersion: '',
  v2BotName: '',
  v2BotRole: '',
  migrationStrategy: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/migrations');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/migrations',
  headers: {'content-type': 'application/json'},
  data: {
    v1BotName: '',
    v1BotVersion: '',
    v2BotName: '',
    v2BotRole: '',
    migrationStrategy: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/migrations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"v1BotName":"","v1BotVersion":"","v2BotName":"","v2BotRole":"","migrationStrategy":""}'
};

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}}/migrations',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "v1BotName": "",\n  "v1BotVersion": "",\n  "v2BotName": "",\n  "v2BotRole": "",\n  "migrationStrategy": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"v1BotName\": \"\",\n  \"v1BotVersion\": \"\",\n  \"v2BotName\": \"\",\n  \"v2BotRole\": \"\",\n  \"migrationStrategy\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/migrations")
  .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/migrations',
  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({
  v1BotName: '',
  v1BotVersion: '',
  v2BotName: '',
  v2BotRole: '',
  migrationStrategy: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/migrations',
  headers: {'content-type': 'application/json'},
  body: {
    v1BotName: '',
    v1BotVersion: '',
    v2BotName: '',
    v2BotRole: '',
    migrationStrategy: ''
  },
  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}}/migrations');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  v1BotName: '',
  v1BotVersion: '',
  v2BotName: '',
  v2BotRole: '',
  migrationStrategy: ''
});

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}}/migrations',
  headers: {'content-type': 'application/json'},
  data: {
    v1BotName: '',
    v1BotVersion: '',
    v2BotName: '',
    v2BotRole: '',
    migrationStrategy: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/migrations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"v1BotName":"","v1BotVersion":"","v2BotName":"","v2BotRole":"","migrationStrategy":""}'
};

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 = @{ @"v1BotName": @"",
                              @"v1BotVersion": @"",
                              @"v2BotName": @"",
                              @"v2BotRole": @"",
                              @"migrationStrategy": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/migrations"]
                                                       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}}/migrations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"v1BotName\": \"\",\n  \"v1BotVersion\": \"\",\n  \"v2BotName\": \"\",\n  \"v2BotRole\": \"\",\n  \"migrationStrategy\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/migrations",
  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([
    'v1BotName' => '',
    'v1BotVersion' => '',
    'v2BotName' => '',
    'v2BotRole' => '',
    'migrationStrategy' => ''
  ]),
  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}}/migrations', [
  'body' => '{
  "v1BotName": "",
  "v1BotVersion": "",
  "v2BotName": "",
  "v2BotRole": "",
  "migrationStrategy": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/migrations');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'v1BotName' => '',
  'v1BotVersion' => '',
  'v2BotName' => '',
  'v2BotRole' => '',
  'migrationStrategy' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'v1BotName' => '',
  'v1BotVersion' => '',
  'v2BotName' => '',
  'v2BotRole' => '',
  'migrationStrategy' => ''
]));
$request->setRequestUrl('{{baseUrl}}/migrations');
$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}}/migrations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "v1BotName": "",
  "v1BotVersion": "",
  "v2BotName": "",
  "v2BotRole": "",
  "migrationStrategy": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/migrations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "v1BotName": "",
  "v1BotVersion": "",
  "v2BotName": "",
  "v2BotRole": "",
  "migrationStrategy": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"v1BotName\": \"\",\n  \"v1BotVersion\": \"\",\n  \"v2BotName\": \"\",\n  \"v2BotRole\": \"\",\n  \"migrationStrategy\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/migrations", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/migrations"

payload = {
    "v1BotName": "",
    "v1BotVersion": "",
    "v2BotName": "",
    "v2BotRole": "",
    "migrationStrategy": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/migrations"

payload <- "{\n  \"v1BotName\": \"\",\n  \"v1BotVersion\": \"\",\n  \"v2BotName\": \"\",\n  \"v2BotRole\": \"\",\n  \"migrationStrategy\": \"\"\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}}/migrations")

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  \"v1BotName\": \"\",\n  \"v1BotVersion\": \"\",\n  \"v2BotName\": \"\",\n  \"v2BotRole\": \"\",\n  \"migrationStrategy\": \"\"\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/migrations') do |req|
  req.body = "{\n  \"v1BotName\": \"\",\n  \"v1BotVersion\": \"\",\n  \"v2BotName\": \"\",\n  \"v2BotRole\": \"\",\n  \"migrationStrategy\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/migrations";

    let payload = json!({
        "v1BotName": "",
        "v1BotVersion": "",
        "v2BotName": "",
        "v2BotRole": "",
        "migrationStrategy": ""
    });

    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 '{
  "v1BotName": "",
  "v1BotVersion": "",
  "v2BotName": "",
  "v2BotRole": "",
  "migrationStrategy": ""
}' |  \
  http POST {{baseUrl}}/migrations \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "v1BotName": "",\n  "v1BotVersion": "",\n  "v2BotName": "",\n  "v2BotRole": "",\n  "migrationStrategy": ""\n}' \
  --output-document \
  - {{baseUrl}}/migrations

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "v1BotName": "",
  "v1BotVersion": "",
  "v2BotName": "",
  "v2BotRole": "",
  "migrationStrategy": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/migrations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tags/:resourceArn");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/tags/:resourceArn" {:content-type :json
                                                              :form-params {:tags [{:key ""
                                                                                    :value ""}]}})

require "http/client"

url = "{{baseUrl}}/tags/:resourceArn"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/tags/:resourceArn"),
    Content = new StringContent("{\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tags/:resourceArn");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tags/:resourceArn"

	payload := strings.NewReader("{\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/tags/:resourceArn HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 66

{
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/tags/:resourceArn")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tags/:resourceArn"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/tags/:resourceArn")
  .header("content-type", "application/json")
  .body("{\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  tags: [
    {
      key: '',
      value: ''
    }
  ]
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/tags/:resourceArn');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tags/:resourceArn',
  headers: {'content-type': 'application/json'},
  data: {tags: [{key: '', value: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tags/:resourceArn';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"tags":[{"key":"","value":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/tags/:resourceArn',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "tags": [\n    {\n      "key": "",\n      "value": ""\n    }\n  ]\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tags/:resourceArn',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({tags: [{key: '', value: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tags/:resourceArn',
  headers: {'content-type': 'application/json'},
  body: {tags: [{key: '', value: ''}]},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/tags/:resourceArn');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  tags: [
    {
      key: '',
      value: ''
    }
  ]
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/tags/:resourceArn',
  headers: {'content-type': 'application/json'},
  data: {tags: [{key: '', value: ''}]}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tags/:resourceArn';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"tags":[{"key":"","value":""}]}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"tags": @[ @{ @"key": @"", @"value": @"" } ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tags/:resourceArn"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/tags/:resourceArn" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tags/:resourceArn",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'tags' => [
        [
                'key' => '',
                'value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/tags/:resourceArn', [
  'body' => '{
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/tags/:resourceArn');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'tags' => [
    [
        'key' => '',
        'value' => ''
    ]
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'tags' => [
    [
        'key' => '',
        'value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/tags/:resourceArn');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/tags/:resourceArn' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/tags/:resourceArn' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/tags/:resourceArn", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tags/:resourceArn"

payload = { "tags": [
        {
            "key": "",
            "value": ""
        }
    ] }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags/:resourceArn"

payload <- "{\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tags/:resourceArn")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/tags/:resourceArn') do |req|
  req.body = "{\n  \"tags\": [\n    {\n      \"key\": \"\",\n      \"value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tags/:resourceArn";

    let payload = json!({"tags": (
            json!({
                "key": "",
                "value": ""
            })
        )});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "tags": [
    {
      "key": "",
      "value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/tags/:resourceArn \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "tags": [\n    {\n      "key": "",\n      "value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/tags/:resourceArn

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["tags": [
    [
      "key": "",
      "value": ""
    ]
  ]] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tags/:resourceArn")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/delete "{{baseUrl}}/tags/:resourceArn#tagKeys" {:query-params {:tagKeys ""}})

require "http/client"

url = "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys"

response = HTTP::Client.delete url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Delete,
    RequestUri = new Uri("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys"

	req, _ := http.NewRequest("DELETE", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

DELETE /baseUrl/tags/:resourceArn?tagKeys= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")
  .delete(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.delete("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")
  .asString();

const data = null;

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('DELETE', '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/tags/:resourceArn#tagKeys',
  params: {tagKeys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys',
  method: 'DELETE',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")
  .delete(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/tags/:resourceArn?tagKeys=',
  headers: {}
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/tags/:resourceArn#tagKeys',
  qs: {tagKeys: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/tags/:resourceArn#tagKeys');

req.query({
  tagKeys: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/tags/:resourceArn#tagKeys',
  params: {tagKeys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys';
const options = {method: 'DELETE'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys" in

Client.call `DELETE uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('DELETE', '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys');

echo $response->getBody();

setUrl('{{baseUrl}}/tags/:resourceArn#tagKeys');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'tagKeys' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/tags/:resourceArn#tagKeys');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'tagKeys' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys' -Method DELETE 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("DELETE", "/baseUrl/tags/:resourceArn?tagKeys=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/tags/:resourceArn#tagKeys"

querystring = {"tagKeys":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/tags/:resourceArn#tagKeys"

queryString <- list(tagKeys = "")

response <- VERB("DELETE", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Delete.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.delete('/baseUrl/tags/:resourceArn') do |req|
  req.params['tagKeys'] = ''
end

puts response.status
puts response.body

use std::str::FromStr;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/tags/:resourceArn#tagKeys";

    let querystring = [
        ("tagKeys", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("DELETE").unwrap(), url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http DELETE '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys'

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/tags/:resourceArn?tagKeys=#tagKeys")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()