AWS Lambdav2015-03-31

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy");

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  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"OrganizationId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy" {:content-type :json
                                                                                                        :form-params {:StatementId ""
                                                                                                                      :Action ""
                                                                                                                      :Principal ""
                                                                                                                      :OrganizationId ""}})

require "http/client"

url = "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"OrganizationId\": \"\"\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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy"),
    Content = new StringContent("{\n  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"OrganizationId\": \"\"\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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"OrganizationId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy"

	payload := strings.NewReader("{\n  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"OrganizationId\": \"\"\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/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 82

{
  "StatementId": "",
  "Action": "",
  "Principal": "",
  "OrganizationId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"OrganizationId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"OrganizationId\": \"\"\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  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"OrganizationId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy")
  .header("content-type", "application/json")
  .body("{\n  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"OrganizationId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  StatementId: '',
  Action: '',
  Principal: '',
  OrganizationId: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy',
  headers: {'content-type': 'application/json'},
  data: {StatementId: '', Action: '', Principal: '', OrganizationId: ''}
};

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

const url = '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"StatementId":"","Action":"","Principal":"","OrganizationId":""}'
};

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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "StatementId": "",\n  "Action": "",\n  "Principal": "",\n  "OrganizationId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"OrganizationId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy")
  .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/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy',
  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({StatementId: '', Action: '', Principal: '', OrganizationId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy',
  headers: {'content-type': 'application/json'},
  body: {StatementId: '', Action: '', Principal: '', OrganizationId: ''},
  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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy');

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

req.type('json');
req.send({
  StatementId: '',
  Action: '',
  Principal: '',
  OrganizationId: ''
});

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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy',
  headers: {'content-type': 'application/json'},
  data: {StatementId: '', Action: '', Principal: '', OrganizationId: ''}
};

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

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

const url = '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"StatementId":"","Action":"","Principal":"","OrganizationId":""}'
};

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 = @{ @"StatementId": @"",
                              @"Action": @"",
                              @"Principal": @"",
                              @"OrganizationId": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy"]
                                                       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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"OrganizationId\": \"\"\n}" in

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

 "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy",
  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([
    'StatementId' => '',
    'Action' => '',
    'Principal' => '',
    'OrganizationId' => ''
  ]),
  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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy', [
  'body' => '{
  "StatementId": "",
  "Action": "",
  "Principal": "",
  "OrganizationId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'StatementId' => '',
  'Action' => '',
  'Principal' => '',
  'OrganizationId' => ''
]));

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

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

append(json_encode([
  'StatementId' => '',
  'Action' => '',
  'Principal' => '',
  'OrganizationId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy');
$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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StatementId": "",
  "Action": "",
  "Principal": "",
  "OrganizationId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StatementId": "",
  "Action": "",
  "Principal": "",
  "OrganizationId": ""
}'

import http.client

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

payload = "{\n  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"OrganizationId\": \"\"\n}"

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

conn.request("POST", "/baseUrl/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy", payload, headers)

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

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

import requests

url = "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy"

payload = {
    "StatementId": "",
    "Action": "",
    "Principal": "",
    "OrganizationId": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy"

payload <- "{\n  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"OrganizationId\": \"\"\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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy")

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  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"OrganizationId\": \"\"\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/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy') do |req|
  req.body = "{\n  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"OrganizationId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy";

    let payload = json!({
        "StatementId": "",
        "Action": "",
        "Principal": "",
        "OrganizationId": ""
    });

    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 '{
  "StatementId": "",
  "Action": "",
  "Principal": "",
  "OrganizationId": ""
}' |  \
  http POST {{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "StatementId": "",\n  "Action": "",\n  "Principal": "",\n  "OrganizationId": ""\n}' \
  --output-document \
  - {{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "StatementId": "",
  "Action": "",
  "Principal": "",
  "OrganizationId": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy")! 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}}/2015-03-31/functions/:FunctionName/policy");

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  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"SourceArn\": \"\",\n  \"SourceAccount\": \"\",\n  \"EventSourceToken\": \"\",\n  \"RevisionId\": \"\",\n  \"PrincipalOrgID\": \"\",\n  \"FunctionUrlAuthType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/2015-03-31/functions/:FunctionName/policy" {:content-type :json
                                                                                      :form-params {:StatementId ""
                                                                                                    :Action ""
                                                                                                    :Principal ""
                                                                                                    :SourceArn ""
                                                                                                    :SourceAccount ""
                                                                                                    :EventSourceToken ""
                                                                                                    :RevisionId ""
                                                                                                    :PrincipalOrgID ""
                                                                                                    :FunctionUrlAuthType ""}})

require "http/client"

url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/policy"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"SourceArn\": \"\",\n  \"SourceAccount\": \"\",\n  \"EventSourceToken\": \"\",\n  \"RevisionId\": \"\",\n  \"PrincipalOrgID\": \"\",\n  \"FunctionUrlAuthType\": \"\"\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}}/2015-03-31/functions/:FunctionName/policy"),
    Content = new StringContent("{\n  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"SourceArn\": \"\",\n  \"SourceAccount\": \"\",\n  \"EventSourceToken\": \"\",\n  \"RevisionId\": \"\",\n  \"PrincipalOrgID\": \"\",\n  \"FunctionUrlAuthType\": \"\"\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}}/2015-03-31/functions/:FunctionName/policy");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"SourceArn\": \"\",\n  \"SourceAccount\": \"\",\n  \"EventSourceToken\": \"\",\n  \"RevisionId\": \"\",\n  \"PrincipalOrgID\": \"\",\n  \"FunctionUrlAuthType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-03-31/functions/:FunctionName/policy"

	payload := strings.NewReader("{\n  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"SourceArn\": \"\",\n  \"SourceAccount\": \"\",\n  \"EventSourceToken\": \"\",\n  \"RevisionId\": \"\",\n  \"PrincipalOrgID\": \"\",\n  \"FunctionUrlAuthType\": \"\"\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/2015-03-31/functions/:FunctionName/policy HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 199

{
  "StatementId": "",
  "Action": "",
  "Principal": "",
  "SourceArn": "",
  "SourceAccount": "",
  "EventSourceToken": "",
  "RevisionId": "",
  "PrincipalOrgID": "",
  "FunctionUrlAuthType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-03-31/functions/:FunctionName/policy")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"SourceArn\": \"\",\n  \"SourceAccount\": \"\",\n  \"EventSourceToken\": \"\",\n  \"RevisionId\": \"\",\n  \"PrincipalOrgID\": \"\",\n  \"FunctionUrlAuthType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-03-31/functions/:FunctionName/policy"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"SourceArn\": \"\",\n  \"SourceAccount\": \"\",\n  \"EventSourceToken\": \"\",\n  \"RevisionId\": \"\",\n  \"PrincipalOrgID\": \"\",\n  \"FunctionUrlAuthType\": \"\"\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  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"SourceArn\": \"\",\n  \"SourceAccount\": \"\",\n  \"EventSourceToken\": \"\",\n  \"RevisionId\": \"\",\n  \"PrincipalOrgID\": \"\",\n  \"FunctionUrlAuthType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-03-31/functions/:FunctionName/policy")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/2015-03-31/functions/:FunctionName/policy")
  .header("content-type", "application/json")
  .body("{\n  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"SourceArn\": \"\",\n  \"SourceAccount\": \"\",\n  \"EventSourceToken\": \"\",\n  \"RevisionId\": \"\",\n  \"PrincipalOrgID\": \"\",\n  \"FunctionUrlAuthType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  StatementId: '',
  Action: '',
  Principal: '',
  SourceArn: '',
  SourceAccount: '',
  EventSourceToken: '',
  RevisionId: '',
  PrincipalOrgID: '',
  FunctionUrlAuthType: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/2015-03-31/functions/:FunctionName/policy');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-03-31/functions/:FunctionName/policy',
  headers: {'content-type': 'application/json'},
  data: {
    StatementId: '',
    Action: '',
    Principal: '',
    SourceArn: '',
    SourceAccount: '',
    EventSourceToken: '',
    RevisionId: '',
    PrincipalOrgID: '',
    FunctionUrlAuthType: ''
  }
};

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

const url = '{{baseUrl}}/2015-03-31/functions/:FunctionName/policy';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"StatementId":"","Action":"","Principal":"","SourceArn":"","SourceAccount":"","EventSourceToken":"","RevisionId":"","PrincipalOrgID":"","FunctionUrlAuthType":""}'
};

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}}/2015-03-31/functions/:FunctionName/policy',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "StatementId": "",\n  "Action": "",\n  "Principal": "",\n  "SourceArn": "",\n  "SourceAccount": "",\n  "EventSourceToken": "",\n  "RevisionId": "",\n  "PrincipalOrgID": "",\n  "FunctionUrlAuthType": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"SourceArn\": \"\",\n  \"SourceAccount\": \"\",\n  \"EventSourceToken\": \"\",\n  \"RevisionId\": \"\",\n  \"PrincipalOrgID\": \"\",\n  \"FunctionUrlAuthType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2015-03-31/functions/:FunctionName/policy")
  .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/2015-03-31/functions/:FunctionName/policy',
  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({
  StatementId: '',
  Action: '',
  Principal: '',
  SourceArn: '',
  SourceAccount: '',
  EventSourceToken: '',
  RevisionId: '',
  PrincipalOrgID: '',
  FunctionUrlAuthType: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-03-31/functions/:FunctionName/policy',
  headers: {'content-type': 'application/json'},
  body: {
    StatementId: '',
    Action: '',
    Principal: '',
    SourceArn: '',
    SourceAccount: '',
    EventSourceToken: '',
    RevisionId: '',
    PrincipalOrgID: '',
    FunctionUrlAuthType: ''
  },
  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}}/2015-03-31/functions/:FunctionName/policy');

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

req.type('json');
req.send({
  StatementId: '',
  Action: '',
  Principal: '',
  SourceArn: '',
  SourceAccount: '',
  EventSourceToken: '',
  RevisionId: '',
  PrincipalOrgID: '',
  FunctionUrlAuthType: ''
});

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}}/2015-03-31/functions/:FunctionName/policy',
  headers: {'content-type': 'application/json'},
  data: {
    StatementId: '',
    Action: '',
    Principal: '',
    SourceArn: '',
    SourceAccount: '',
    EventSourceToken: '',
    RevisionId: '',
    PrincipalOrgID: '',
    FunctionUrlAuthType: ''
  }
};

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

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

const url = '{{baseUrl}}/2015-03-31/functions/:FunctionName/policy';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"StatementId":"","Action":"","Principal":"","SourceArn":"","SourceAccount":"","EventSourceToken":"","RevisionId":"","PrincipalOrgID":"","FunctionUrlAuthType":""}'
};

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 = @{ @"StatementId": @"",
                              @"Action": @"",
                              @"Principal": @"",
                              @"SourceArn": @"",
                              @"SourceAccount": @"",
                              @"EventSourceToken": @"",
                              @"RevisionId": @"",
                              @"PrincipalOrgID": @"",
                              @"FunctionUrlAuthType": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-03-31/functions/:FunctionName/policy"]
                                                       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}}/2015-03-31/functions/:FunctionName/policy" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"SourceArn\": \"\",\n  \"SourceAccount\": \"\",\n  \"EventSourceToken\": \"\",\n  \"RevisionId\": \"\",\n  \"PrincipalOrgID\": \"\",\n  \"FunctionUrlAuthType\": \"\"\n}" in

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

 "{{baseUrl}}/2015-03-31/functions/:FunctionName/policy",
  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([
    'StatementId' => '',
    'Action' => '',
    'Principal' => '',
    'SourceArn' => '',
    'SourceAccount' => '',
    'EventSourceToken' => '',
    'RevisionId' => '',
    'PrincipalOrgID' => '',
    'FunctionUrlAuthType' => ''
  ]),
  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}}/2015-03-31/functions/:FunctionName/policy', [
  'body' => '{
  "StatementId": "",
  "Action": "",
  "Principal": "",
  "SourceArn": "",
  "SourceAccount": "",
  "EventSourceToken": "",
  "RevisionId": "",
  "PrincipalOrgID": "",
  "FunctionUrlAuthType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2015-03-31/functions/:FunctionName/policy');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'StatementId' => '',
  'Action' => '',
  'Principal' => '',
  'SourceArn' => '',
  'SourceAccount' => '',
  'EventSourceToken' => '',
  'RevisionId' => '',
  'PrincipalOrgID' => '',
  'FunctionUrlAuthType' => ''
]));

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

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

append(json_encode([
  'StatementId' => '',
  'Action' => '',
  'Principal' => '',
  'SourceArn' => '',
  'SourceAccount' => '',
  'EventSourceToken' => '',
  'RevisionId' => '',
  'PrincipalOrgID' => '',
  'FunctionUrlAuthType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/2015-03-31/functions/:FunctionName/policy');
$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}}/2015-03-31/functions/:FunctionName/policy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StatementId": "",
  "Action": "",
  "Principal": "",
  "SourceArn": "",
  "SourceAccount": "",
  "EventSourceToken": "",
  "RevisionId": "",
  "PrincipalOrgID": "",
  "FunctionUrlAuthType": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-03-31/functions/:FunctionName/policy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StatementId": "",
  "Action": "",
  "Principal": "",
  "SourceArn": "",
  "SourceAccount": "",
  "EventSourceToken": "",
  "RevisionId": "",
  "PrincipalOrgID": "",
  "FunctionUrlAuthType": ""
}'

import http.client

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

payload = "{\n  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"SourceArn\": \"\",\n  \"SourceAccount\": \"\",\n  \"EventSourceToken\": \"\",\n  \"RevisionId\": \"\",\n  \"PrincipalOrgID\": \"\",\n  \"FunctionUrlAuthType\": \"\"\n}"

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

conn.request("POST", "/baseUrl/2015-03-31/functions/:FunctionName/policy", payload, headers)

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

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

import requests

url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/policy"

payload = {
    "StatementId": "",
    "Action": "",
    "Principal": "",
    "SourceArn": "",
    "SourceAccount": "",
    "EventSourceToken": "",
    "RevisionId": "",
    "PrincipalOrgID": "",
    "FunctionUrlAuthType": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-03-31/functions/:FunctionName/policy"

payload <- "{\n  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"SourceArn\": \"\",\n  \"SourceAccount\": \"\",\n  \"EventSourceToken\": \"\",\n  \"RevisionId\": \"\",\n  \"PrincipalOrgID\": \"\",\n  \"FunctionUrlAuthType\": \"\"\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}}/2015-03-31/functions/:FunctionName/policy")

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  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"SourceArn\": \"\",\n  \"SourceAccount\": \"\",\n  \"EventSourceToken\": \"\",\n  \"RevisionId\": \"\",\n  \"PrincipalOrgID\": \"\",\n  \"FunctionUrlAuthType\": \"\"\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/2015-03-31/functions/:FunctionName/policy') do |req|
  req.body = "{\n  \"StatementId\": \"\",\n  \"Action\": \"\",\n  \"Principal\": \"\",\n  \"SourceArn\": \"\",\n  \"SourceAccount\": \"\",\n  \"EventSourceToken\": \"\",\n  \"RevisionId\": \"\",\n  \"PrincipalOrgID\": \"\",\n  \"FunctionUrlAuthType\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/policy";

    let payload = json!({
        "StatementId": "",
        "Action": "",
        "Principal": "",
        "SourceArn": "",
        "SourceAccount": "",
        "EventSourceToken": "",
        "RevisionId": "",
        "PrincipalOrgID": "",
        "FunctionUrlAuthType": ""
    });

    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 '{
  "StatementId": "",
  "Action": "",
  "Principal": "",
  "SourceArn": "",
  "SourceAccount": "",
  "EventSourceToken": "",
  "RevisionId": "",
  "PrincipalOrgID": "",
  "FunctionUrlAuthType": ""
}' |  \
  http POST {{baseUrl}}/2015-03-31/functions/:FunctionName/policy \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "StatementId": "",\n  "Action": "",\n  "Principal": "",\n  "SourceArn": "",\n  "SourceAccount": "",\n  "EventSourceToken": "",\n  "RevisionId": "",\n  "PrincipalOrgID": "",\n  "FunctionUrlAuthType": ""\n}' \
  --output-document \
  - {{baseUrl}}/2015-03-31/functions/:FunctionName/policy

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "StatementId": "",
  "Action": "",
  "Principal": "",
  "SourceArn": "",
  "SourceAccount": "",
  "EventSourceToken": "",
  "RevisionId": "",
  "PrincipalOrgID": "",
  "FunctionUrlAuthType": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-03-31/functions/:FunctionName/policy")! 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}}/2015-03-31/functions/:FunctionName/aliases");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Name\": \"\",\n  \"FunctionVersion\": \"\",\n  \"Description\": \"\",\n  \"RoutingConfig\": {\n    \"AdditionalVersionWeights\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases" {:content-type :json
                                                                                       :form-params {:Name ""
                                                                                                     :FunctionVersion ""
                                                                                                     :Description ""
                                                                                                     :RoutingConfig {:AdditionalVersionWeights ""}}})

require "http/client"

url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"FunctionVersion\": \"\",\n  \"Description\": \"\",\n  \"RoutingConfig\": {\n    \"AdditionalVersionWeights\": \"\"\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}}/2015-03-31/functions/:FunctionName/aliases"),
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"FunctionVersion\": \"\",\n  \"Description\": \"\",\n  \"RoutingConfig\": {\n    \"AdditionalVersionWeights\": \"\"\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}}/2015-03-31/functions/:FunctionName/aliases");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"FunctionVersion\": \"\",\n  \"Description\": \"\",\n  \"RoutingConfig\": {\n    \"AdditionalVersionWeights\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"FunctionVersion\": \"\",\n  \"Description\": \"\",\n  \"RoutingConfig\": {\n    \"AdditionalVersionWeights\": \"\"\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/2015-03-31/functions/:FunctionName/aliases HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 123

{
  "Name": "",
  "FunctionVersion": "",
  "Description": "",
  "RoutingConfig": {
    "AdditionalVersionWeights": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"FunctionVersion\": \"\",\n  \"Description\": \"\",\n  \"RoutingConfig\": {\n    \"AdditionalVersionWeights\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"FunctionVersion\": \"\",\n  \"Description\": \"\",\n  \"RoutingConfig\": {\n    \"AdditionalVersionWeights\": \"\"\n  }\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"FunctionVersion\": \"\",\n  \"Description\": \"\",\n  \"RoutingConfig\": {\n    \"AdditionalVersionWeights\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"FunctionVersion\": \"\",\n  \"Description\": \"\",\n  \"RoutingConfig\": {\n    \"AdditionalVersionWeights\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  FunctionVersion: '',
  Description: '',
  RoutingConfig: {
    AdditionalVersionWeights: ''
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    FunctionVersion: '',
    Description: '',
    RoutingConfig: {AdditionalVersionWeights: ''}
  }
};

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

const url = '{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","FunctionVersion":"","Description":"","RoutingConfig":{"AdditionalVersionWeights":""}}'
};

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}}/2015-03-31/functions/:FunctionName/aliases',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "FunctionVersion": "",\n  "Description": "",\n  "RoutingConfig": {\n    "AdditionalVersionWeights": ""\n  }\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"FunctionVersion\": \"\",\n  \"Description\": \"\",\n  \"RoutingConfig\": {\n    \"AdditionalVersionWeights\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases")
  .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/2015-03-31/functions/:FunctionName/aliases',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({
  Name: '',
  FunctionVersion: '',
  Description: '',
  RoutingConfig: {AdditionalVersionWeights: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases',
  headers: {'content-type': 'application/json'},
  body: {
    Name: '',
    FunctionVersion: '',
    Description: '',
    RoutingConfig: {AdditionalVersionWeights: ''}
  },
  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}}/2015-03-31/functions/:FunctionName/aliases');

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

req.type('json');
req.send({
  Name: '',
  FunctionVersion: '',
  Description: '',
  RoutingConfig: {
    AdditionalVersionWeights: ''
  }
});

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}}/2015-03-31/functions/:FunctionName/aliases',
  headers: {'content-type': 'application/json'},
  data: {
    Name: '',
    FunctionVersion: '',
    Description: '',
    RoutingConfig: {AdditionalVersionWeights: ''}
  }
};

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

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

const url = '{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Name":"","FunctionVersion":"","Description":"","RoutingConfig":{"AdditionalVersionWeights":""}}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"FunctionVersion": @"",
                              @"Description": @"",
                              @"RoutingConfig": @{ @"AdditionalVersionWeights": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases"]
                                                       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}}/2015-03-31/functions/:FunctionName/aliases" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"FunctionVersion\": \"\",\n  \"Description\": \"\",\n  \"RoutingConfig\": {\n    \"AdditionalVersionWeights\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'FunctionVersion' => '',
    'Description' => '',
    'RoutingConfig' => [
        'AdditionalVersionWeights' => ''
    ]
  ]),
  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}}/2015-03-31/functions/:FunctionName/aliases', [
  'body' => '{
  "Name": "",
  "FunctionVersion": "",
  "Description": "",
  "RoutingConfig": {
    "AdditionalVersionWeights": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'FunctionVersion' => '',
  'Description' => '',
  'RoutingConfig' => [
    'AdditionalVersionWeights' => ''
  ]
]));

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

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

append(json_encode([
  'Name' => '',
  'FunctionVersion' => '',
  'Description' => '',
  'RoutingConfig' => [
    'AdditionalVersionWeights' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases');
$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}}/2015-03-31/functions/:FunctionName/aliases' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "FunctionVersion": "",
  "Description": "",
  "RoutingConfig": {
    "AdditionalVersionWeights": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "FunctionVersion": "",
  "Description": "",
  "RoutingConfig": {
    "AdditionalVersionWeights": ""
  }
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"FunctionVersion\": \"\",\n  \"Description\": \"\",\n  \"RoutingConfig\": {\n    \"AdditionalVersionWeights\": \"\"\n  }\n}"

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

conn.request("POST", "/baseUrl/2015-03-31/functions/:FunctionName/aliases", payload, headers)

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

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

import requests

url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases"

payload = {
    "Name": "",
    "FunctionVersion": "",
    "Description": "",
    "RoutingConfig": { "AdditionalVersionWeights": "" }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases"

payload <- "{\n  \"Name\": \"\",\n  \"FunctionVersion\": \"\",\n  \"Description\": \"\",\n  \"RoutingConfig\": {\n    \"AdditionalVersionWeights\": \"\"\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}}/2015-03-31/functions/:FunctionName/aliases")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Name\": \"\",\n  \"FunctionVersion\": \"\",\n  \"Description\": \"\",\n  \"RoutingConfig\": {\n    \"AdditionalVersionWeights\": \"\"\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/2015-03-31/functions/:FunctionName/aliases') do |req|
  req.body = "{\n  \"Name\": \"\",\n  \"FunctionVersion\": \"\",\n  \"Description\": \"\",\n  \"RoutingConfig\": {\n    \"AdditionalVersionWeights\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases";

    let payload = json!({
        "Name": "",
        "FunctionVersion": "",
        "Description": "",
        "RoutingConfig": json!({"AdditionalVersionWeights": ""})
    });

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

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

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

    dbg!(results);
}

echo '{
  "Name": "",
  "FunctionVersion": "",
  "Description": "",
  "RoutingConfig": {
    "AdditionalVersionWeights": ""
  }
}' |  \
  http POST {{baseUrl}}/2015-03-31/functions/:FunctionName/aliases \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "FunctionVersion": "",\n  "Description": "",\n  "RoutingConfig": {\n    "AdditionalVersionWeights": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/2015-03-31/functions/:FunctionName/aliases

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Name": "",
  "FunctionVersion": "",
  "Description": "",
  "RoutingConfig": ["AdditionalVersionWeights": ""]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases")! 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}}/2020-04-22/code-signing-configs/");

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  \"AllowedPublishers\": {\n    \"SigningProfileVersionArns\": \"\"\n  },\n  \"CodeSigningPolicies\": {\n    \"UntrustedArtifactOnDeployment\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/2020-04-22/code-signing-configs/" {:content-type :json
                                                                             :form-params {:Description ""
                                                                                           :AllowedPublishers {:SigningProfileVersionArns ""}
                                                                                           :CodeSigningPolicies {:UntrustedArtifactOnDeployment ""}}})

require "http/client"

url = "{{baseUrl}}/2020-04-22/code-signing-configs/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Description\": \"\",\n  \"AllowedPublishers\": {\n    \"SigningProfileVersionArns\": \"\"\n  },\n  \"CodeSigningPolicies\": {\n    \"UntrustedArtifactOnDeployment\": \"\"\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}}/2020-04-22/code-signing-configs/"),
    Content = new StringContent("{\n  \"Description\": \"\",\n  \"AllowedPublishers\": {\n    \"SigningProfileVersionArns\": \"\"\n  },\n  \"CodeSigningPolicies\": {\n    \"UntrustedArtifactOnDeployment\": \"\"\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}}/2020-04-22/code-signing-configs/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Description\": \"\",\n  \"AllowedPublishers\": {\n    \"SigningProfileVersionArns\": \"\"\n  },\n  \"CodeSigningPolicies\": {\n    \"UntrustedArtifactOnDeployment\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2020-04-22/code-signing-configs/"

	payload := strings.NewReader("{\n  \"Description\": \"\",\n  \"AllowedPublishers\": {\n    \"SigningProfileVersionArns\": \"\"\n  },\n  \"CodeSigningPolicies\": {\n    \"UntrustedArtifactOnDeployment\": \"\"\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/2020-04-22/code-signing-configs/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 161

{
  "Description": "",
  "AllowedPublishers": {
    "SigningProfileVersionArns": ""
  },
  "CodeSigningPolicies": {
    "UntrustedArtifactOnDeployment": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2020-04-22/code-signing-configs/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Description\": \"\",\n  \"AllowedPublishers\": {\n    \"SigningProfileVersionArns\": \"\"\n  },\n  \"CodeSigningPolicies\": {\n    \"UntrustedArtifactOnDeployment\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2020-04-22/code-signing-configs/"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Description\": \"\",\n  \"AllowedPublishers\": {\n    \"SigningProfileVersionArns\": \"\"\n  },\n  \"CodeSigningPolicies\": {\n    \"UntrustedArtifactOnDeployment\": \"\"\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  \"AllowedPublishers\": {\n    \"SigningProfileVersionArns\": \"\"\n  },\n  \"CodeSigningPolicies\": {\n    \"UntrustedArtifactOnDeployment\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2020-04-22/code-signing-configs/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/2020-04-22/code-signing-configs/")
  .header("content-type", "application/json")
  .body("{\n  \"Description\": \"\",\n  \"AllowedPublishers\": {\n    \"SigningProfileVersionArns\": \"\"\n  },\n  \"CodeSigningPolicies\": {\n    \"UntrustedArtifactOnDeployment\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  Description: '',
  AllowedPublishers: {
    SigningProfileVersionArns: ''
  },
  CodeSigningPolicies: {
    UntrustedArtifactOnDeployment: ''
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/2020-04-22/code-signing-configs/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2020-04-22/code-signing-configs/',
  headers: {'content-type': 'application/json'},
  data: {
    Description: '',
    AllowedPublishers: {SigningProfileVersionArns: ''},
    CodeSigningPolicies: {UntrustedArtifactOnDeployment: ''}
  }
};

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

const url = '{{baseUrl}}/2020-04-22/code-signing-configs/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Description":"","AllowedPublishers":{"SigningProfileVersionArns":""},"CodeSigningPolicies":{"UntrustedArtifactOnDeployment":""}}'
};

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}}/2020-04-22/code-signing-configs/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Description": "",\n  "AllowedPublishers": {\n    "SigningProfileVersionArns": ""\n  },\n  "CodeSigningPolicies": {\n    "UntrustedArtifactOnDeployment": ""\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  \"AllowedPublishers\": {\n    \"SigningProfileVersionArns\": \"\"\n  },\n  \"CodeSigningPolicies\": {\n    \"UntrustedArtifactOnDeployment\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2020-04-22/code-signing-configs/")
  .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/2020-04-22/code-signing-configs/',
  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: '',
  AllowedPublishers: {SigningProfileVersionArns: ''},
  CodeSigningPolicies: {UntrustedArtifactOnDeployment: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2020-04-22/code-signing-configs/',
  headers: {'content-type': 'application/json'},
  body: {
    Description: '',
    AllowedPublishers: {SigningProfileVersionArns: ''},
    CodeSigningPolicies: {UntrustedArtifactOnDeployment: ''}
  },
  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}}/2020-04-22/code-signing-configs/');

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

req.type('json');
req.send({
  Description: '',
  AllowedPublishers: {
    SigningProfileVersionArns: ''
  },
  CodeSigningPolicies: {
    UntrustedArtifactOnDeployment: ''
  }
});

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}}/2020-04-22/code-signing-configs/',
  headers: {'content-type': 'application/json'},
  data: {
    Description: '',
    AllowedPublishers: {SigningProfileVersionArns: ''},
    CodeSigningPolicies: {UntrustedArtifactOnDeployment: ''}
  }
};

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

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

const url = '{{baseUrl}}/2020-04-22/code-signing-configs/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Description":"","AllowedPublishers":{"SigningProfileVersionArns":""},"CodeSigningPolicies":{"UntrustedArtifactOnDeployment":""}}'
};

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": @"",
                              @"AllowedPublishers": @{ @"SigningProfileVersionArns": @"" },
                              @"CodeSigningPolicies": @{ @"UntrustedArtifactOnDeployment": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2020-04-22/code-signing-configs/"]
                                                       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}}/2020-04-22/code-signing-configs/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Description\": \"\",\n  \"AllowedPublishers\": {\n    \"SigningProfileVersionArns\": \"\"\n  },\n  \"CodeSigningPolicies\": {\n    \"UntrustedArtifactOnDeployment\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/2020-04-22/code-signing-configs/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Description' => '',
    'AllowedPublishers' => [
        'SigningProfileVersionArns' => ''
    ],
    'CodeSigningPolicies' => [
        'UntrustedArtifactOnDeployment' => ''
    ]
  ]),
  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}}/2020-04-22/code-signing-configs/', [
  'body' => '{
  "Description": "",
  "AllowedPublishers": {
    "SigningProfileVersionArns": ""
  },
  "CodeSigningPolicies": {
    "UntrustedArtifactOnDeployment": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2020-04-22/code-signing-configs/');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Description' => '',
  'AllowedPublishers' => [
    'SigningProfileVersionArns' => ''
  ],
  'CodeSigningPolicies' => [
    'UntrustedArtifactOnDeployment' => ''
  ]
]));

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

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

append(json_encode([
  'Description' => '',
  'AllowedPublishers' => [
    'SigningProfileVersionArns' => ''
  ],
  'CodeSigningPolicies' => [
    'UntrustedArtifactOnDeployment' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/2020-04-22/code-signing-configs/');
$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}}/2020-04-22/code-signing-configs/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Description": "",
  "AllowedPublishers": {
    "SigningProfileVersionArns": ""
  },
  "CodeSigningPolicies": {
    "UntrustedArtifactOnDeployment": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2020-04-22/code-signing-configs/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Description": "",
  "AllowedPublishers": {
    "SigningProfileVersionArns": ""
  },
  "CodeSigningPolicies": {
    "UntrustedArtifactOnDeployment": ""
  }
}'

import http.client

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

payload = "{\n  \"Description\": \"\",\n  \"AllowedPublishers\": {\n    \"SigningProfileVersionArns\": \"\"\n  },\n  \"CodeSigningPolicies\": {\n    \"UntrustedArtifactOnDeployment\": \"\"\n  }\n}"

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

conn.request("POST", "/baseUrl/2020-04-22/code-signing-configs/", payload, headers)

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

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

import requests

url = "{{baseUrl}}/2020-04-22/code-signing-configs/"

payload = {
    "Description": "",
    "AllowedPublishers": { "SigningProfileVersionArns": "" },
    "CodeSigningPolicies": { "UntrustedArtifactOnDeployment": "" }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/2020-04-22/code-signing-configs/"

payload <- "{\n  \"Description\": \"\",\n  \"AllowedPublishers\": {\n    \"SigningProfileVersionArns\": \"\"\n  },\n  \"CodeSigningPolicies\": {\n    \"UntrustedArtifactOnDeployment\": \"\"\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}}/2020-04-22/code-signing-configs/")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Description\": \"\",\n  \"AllowedPublishers\": {\n    \"SigningProfileVersionArns\": \"\"\n  },\n  \"CodeSigningPolicies\": {\n    \"UntrustedArtifactOnDeployment\": \"\"\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/2020-04-22/code-signing-configs/') do |req|
  req.body = "{\n  \"Description\": \"\",\n  \"AllowedPublishers\": {\n    \"SigningProfileVersionArns\": \"\"\n  },\n  \"CodeSigningPolicies\": {\n    \"UntrustedArtifactOnDeployment\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2020-04-22/code-signing-configs/";

    let payload = json!({
        "Description": "",
        "AllowedPublishers": json!({"SigningProfileVersionArns": ""}),
        "CodeSigningPolicies": json!({"UntrustedArtifactOnDeployment": ""})
    });

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

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

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

    dbg!(results);
}

echo '{
  "Description": "",
  "AllowedPublishers": {
    "SigningProfileVersionArns": ""
  },
  "CodeSigningPolicies": {
    "UntrustedArtifactOnDeployment": ""
  }
}' |  \
  http POST {{baseUrl}}/2020-04-22/code-signing-configs/ \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Description": "",\n  "AllowedPublishers": {\n    "SigningProfileVersionArns": ""\n  },\n  "CodeSigningPolicies": {\n    "UntrustedArtifactOnDeployment": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/2020-04-22/code-signing-configs/

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Description": "",
  "AllowedPublishers": ["SigningProfileVersionArns": ""],
  "CodeSigningPolicies": ["UntrustedArtifactOnDeployment": ""]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2020-04-22/code-signing-configs/")! 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}}/2015-03-31/event-source-mappings/");

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  \"EventSourceArn\": \"\",\n  \"FunctionName\": \"\",\n  \"Enabled\": false,\n  \"BatchSize\": 0,\n  \"FilterCriteria\": {\n    \"Filters\": \"\"\n  },\n  \"MaximumBatchingWindowInSeconds\": 0,\n  \"ParallelizationFactor\": 0,\n  \"StartingPosition\": \"\",\n  \"StartingPositionTimestamp\": \"\",\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\n  },\n  \"MaximumRecordAgeInSeconds\": 0,\n  \"BisectBatchOnFunctionError\": false,\n  \"MaximumRetryAttempts\": 0,\n  \"TumblingWindowInSeconds\": 0,\n  \"Topics\": [],\n  \"Queues\": [],\n  \"SourceAccessConfigurations\": [\n    {\n      \"Type\": \"\",\n      \"URI\": \"\"\n    }\n  ],\n  \"SelfManagedEventSource\": {\n    \"Endpoints\": \"\"\n  },\n  \"FunctionResponseTypes\": [],\n  \"AmazonManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"SelfManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"ScalingConfig\": {\n    \"MaximumConcurrency\": \"\"\n  },\n  \"DocumentDBEventSourceConfig\": {\n    \"DatabaseName\": \"\",\n    \"CollectionName\": \"\",\n    \"FullDocument\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/2015-03-31/event-source-mappings/" {:content-type :json
                                                                              :form-params {:EventSourceArn ""
                                                                                            :FunctionName ""
                                                                                            :Enabled false
                                                                                            :BatchSize 0
                                                                                            :FilterCriteria {:Filters ""}
                                                                                            :MaximumBatchingWindowInSeconds 0
                                                                                            :ParallelizationFactor 0
                                                                                            :StartingPosition ""
                                                                                            :StartingPositionTimestamp ""
                                                                                            :DestinationConfig {:OnSuccess ""
                                                                                                                :OnFailure ""}
                                                                                            :MaximumRecordAgeInSeconds 0
                                                                                            :BisectBatchOnFunctionError false
                                                                                            :MaximumRetryAttempts 0
                                                                                            :TumblingWindowInSeconds 0
                                                                                            :Topics []
                                                                                            :Queues []
                                                                                            :SourceAccessConfigurations [{:Type ""
                                                                                                                          :URI ""}]
                                                                                            :SelfManagedEventSource {:Endpoints ""}
                                                                                            :FunctionResponseTypes []
                                                                                            :AmazonManagedKafkaEventSourceConfig {:ConsumerGroupId ""}
                                                                                            :SelfManagedKafkaEventSourceConfig {:ConsumerGroupId ""}
                                                                                            :ScalingConfig {:MaximumConcurrency ""}
                                                                                            :DocumentDBEventSourceConfig {:DatabaseName ""
                                                                                                                          :CollectionName ""
                                                                                                                          :FullDocument ""}}})

require "http/client"

url = "{{baseUrl}}/2015-03-31/event-source-mappings/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"EventSourceArn\": \"\",\n  \"FunctionName\": \"\",\n  \"Enabled\": false,\n  \"BatchSize\": 0,\n  \"FilterCriteria\": {\n    \"Filters\": \"\"\n  },\n  \"MaximumBatchingWindowInSeconds\": 0,\n  \"ParallelizationFactor\": 0,\n  \"StartingPosition\": \"\",\n  \"StartingPositionTimestamp\": \"\",\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\n  },\n  \"MaximumRecordAgeInSeconds\": 0,\n  \"BisectBatchOnFunctionError\": false,\n  \"MaximumRetryAttempts\": 0,\n  \"TumblingWindowInSeconds\": 0,\n  \"Topics\": [],\n  \"Queues\": [],\n  \"SourceAccessConfigurations\": [\n    {\n      \"Type\": \"\",\n      \"URI\": \"\"\n    }\n  ],\n  \"SelfManagedEventSource\": {\n    \"Endpoints\": \"\"\n  },\n  \"FunctionResponseTypes\": [],\n  \"AmazonManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"SelfManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"ScalingConfig\": {\n    \"MaximumConcurrency\": \"\"\n  },\n  \"DocumentDBEventSourceConfig\": {\n    \"DatabaseName\": \"\",\n    \"CollectionName\": \"\",\n    \"FullDocument\": \"\"\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}}/2015-03-31/event-source-mappings/"),
    Content = new StringContent("{\n  \"EventSourceArn\": \"\",\n  \"FunctionName\": \"\",\n  \"Enabled\": false,\n  \"BatchSize\": 0,\n  \"FilterCriteria\": {\n    \"Filters\": \"\"\n  },\n  \"MaximumBatchingWindowInSeconds\": 0,\n  \"ParallelizationFactor\": 0,\n  \"StartingPosition\": \"\",\n  \"StartingPositionTimestamp\": \"\",\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\n  },\n  \"MaximumRecordAgeInSeconds\": 0,\n  \"BisectBatchOnFunctionError\": false,\n  \"MaximumRetryAttempts\": 0,\n  \"TumblingWindowInSeconds\": 0,\n  \"Topics\": [],\n  \"Queues\": [],\n  \"SourceAccessConfigurations\": [\n    {\n      \"Type\": \"\",\n      \"URI\": \"\"\n    }\n  ],\n  \"SelfManagedEventSource\": {\n    \"Endpoints\": \"\"\n  },\n  \"FunctionResponseTypes\": [],\n  \"AmazonManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"SelfManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"ScalingConfig\": {\n    \"MaximumConcurrency\": \"\"\n  },\n  \"DocumentDBEventSourceConfig\": {\n    \"DatabaseName\": \"\",\n    \"CollectionName\": \"\",\n    \"FullDocument\": \"\"\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}}/2015-03-31/event-source-mappings/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"EventSourceArn\": \"\",\n  \"FunctionName\": \"\",\n  \"Enabled\": false,\n  \"BatchSize\": 0,\n  \"FilterCriteria\": {\n    \"Filters\": \"\"\n  },\n  \"MaximumBatchingWindowInSeconds\": 0,\n  \"ParallelizationFactor\": 0,\n  \"StartingPosition\": \"\",\n  \"StartingPositionTimestamp\": \"\",\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\n  },\n  \"MaximumRecordAgeInSeconds\": 0,\n  \"BisectBatchOnFunctionError\": false,\n  \"MaximumRetryAttempts\": 0,\n  \"TumblingWindowInSeconds\": 0,\n  \"Topics\": [],\n  \"Queues\": [],\n  \"SourceAccessConfigurations\": [\n    {\n      \"Type\": \"\",\n      \"URI\": \"\"\n    }\n  ],\n  \"SelfManagedEventSource\": {\n    \"Endpoints\": \"\"\n  },\n  \"FunctionResponseTypes\": [],\n  \"AmazonManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"SelfManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"ScalingConfig\": {\n    \"MaximumConcurrency\": \"\"\n  },\n  \"DocumentDBEventSourceConfig\": {\n    \"DatabaseName\": \"\",\n    \"CollectionName\": \"\",\n    \"FullDocument\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-03-31/event-source-mappings/"

	payload := strings.NewReader("{\n  \"EventSourceArn\": \"\",\n  \"FunctionName\": \"\",\n  \"Enabled\": false,\n  \"BatchSize\": 0,\n  \"FilterCriteria\": {\n    \"Filters\": \"\"\n  },\n  \"MaximumBatchingWindowInSeconds\": 0,\n  \"ParallelizationFactor\": 0,\n  \"StartingPosition\": \"\",\n  \"StartingPositionTimestamp\": \"\",\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\n  },\n  \"MaximumRecordAgeInSeconds\": 0,\n  \"BisectBatchOnFunctionError\": false,\n  \"MaximumRetryAttempts\": 0,\n  \"TumblingWindowInSeconds\": 0,\n  \"Topics\": [],\n  \"Queues\": [],\n  \"SourceAccessConfigurations\": [\n    {\n      \"Type\": \"\",\n      \"URI\": \"\"\n    }\n  ],\n  \"SelfManagedEventSource\": {\n    \"Endpoints\": \"\"\n  },\n  \"FunctionResponseTypes\": [],\n  \"AmazonManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"SelfManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"ScalingConfig\": {\n    \"MaximumConcurrency\": \"\"\n  },\n  \"DocumentDBEventSourceConfig\": {\n    \"DatabaseName\": \"\",\n    \"CollectionName\": \"\",\n    \"FullDocument\": \"\"\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/2015-03-31/event-source-mappings/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 983

{
  "EventSourceArn": "",
  "FunctionName": "",
  "Enabled": false,
  "BatchSize": 0,
  "FilterCriteria": {
    "Filters": ""
  },
  "MaximumBatchingWindowInSeconds": 0,
  "ParallelizationFactor": 0,
  "StartingPosition": "",
  "StartingPositionTimestamp": "",
  "DestinationConfig": {
    "OnSuccess": "",
    "OnFailure": ""
  },
  "MaximumRecordAgeInSeconds": 0,
  "BisectBatchOnFunctionError": false,
  "MaximumRetryAttempts": 0,
  "TumblingWindowInSeconds": 0,
  "Topics": [],
  "Queues": [],
  "SourceAccessConfigurations": [
    {
      "Type": "",
      "URI": ""
    }
  ],
  "SelfManagedEventSource": {
    "Endpoints": ""
  },
  "FunctionResponseTypes": [],
  "AmazonManagedKafkaEventSourceConfig": {
    "ConsumerGroupId": ""
  },
  "SelfManagedKafkaEventSourceConfig": {
    "ConsumerGroupId": ""
  },
  "ScalingConfig": {
    "MaximumConcurrency": ""
  },
  "DocumentDBEventSourceConfig": {
    "DatabaseName": "",
    "CollectionName": "",
    "FullDocument": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-03-31/event-source-mappings/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"EventSourceArn\": \"\",\n  \"FunctionName\": \"\",\n  \"Enabled\": false,\n  \"BatchSize\": 0,\n  \"FilterCriteria\": {\n    \"Filters\": \"\"\n  },\n  \"MaximumBatchingWindowInSeconds\": 0,\n  \"ParallelizationFactor\": 0,\n  \"StartingPosition\": \"\",\n  \"StartingPositionTimestamp\": \"\",\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\n  },\n  \"MaximumRecordAgeInSeconds\": 0,\n  \"BisectBatchOnFunctionError\": false,\n  \"MaximumRetryAttempts\": 0,\n  \"TumblingWindowInSeconds\": 0,\n  \"Topics\": [],\n  \"Queues\": [],\n  \"SourceAccessConfigurations\": [\n    {\n      \"Type\": \"\",\n      \"URI\": \"\"\n    }\n  ],\n  \"SelfManagedEventSource\": {\n    \"Endpoints\": \"\"\n  },\n  \"FunctionResponseTypes\": [],\n  \"AmazonManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"SelfManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"ScalingConfig\": {\n    \"MaximumConcurrency\": \"\"\n  },\n  \"DocumentDBEventSourceConfig\": {\n    \"DatabaseName\": \"\",\n    \"CollectionName\": \"\",\n    \"FullDocument\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-03-31/event-source-mappings/"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"EventSourceArn\": \"\",\n  \"FunctionName\": \"\",\n  \"Enabled\": false,\n  \"BatchSize\": 0,\n  \"FilterCriteria\": {\n    \"Filters\": \"\"\n  },\n  \"MaximumBatchingWindowInSeconds\": 0,\n  \"ParallelizationFactor\": 0,\n  \"StartingPosition\": \"\",\n  \"StartingPositionTimestamp\": \"\",\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\n  },\n  \"MaximumRecordAgeInSeconds\": 0,\n  \"BisectBatchOnFunctionError\": false,\n  \"MaximumRetryAttempts\": 0,\n  \"TumblingWindowInSeconds\": 0,\n  \"Topics\": [],\n  \"Queues\": [],\n  \"SourceAccessConfigurations\": [\n    {\n      \"Type\": \"\",\n      \"URI\": \"\"\n    }\n  ],\n  \"SelfManagedEventSource\": {\n    \"Endpoints\": \"\"\n  },\n  \"FunctionResponseTypes\": [],\n  \"AmazonManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"SelfManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"ScalingConfig\": {\n    \"MaximumConcurrency\": \"\"\n  },\n  \"DocumentDBEventSourceConfig\": {\n    \"DatabaseName\": \"\",\n    \"CollectionName\": \"\",\n    \"FullDocument\": \"\"\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  \"EventSourceArn\": \"\",\n  \"FunctionName\": \"\",\n  \"Enabled\": false,\n  \"BatchSize\": 0,\n  \"FilterCriteria\": {\n    \"Filters\": \"\"\n  },\n  \"MaximumBatchingWindowInSeconds\": 0,\n  \"ParallelizationFactor\": 0,\n  \"StartingPosition\": \"\",\n  \"StartingPositionTimestamp\": \"\",\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\n  },\n  \"MaximumRecordAgeInSeconds\": 0,\n  \"BisectBatchOnFunctionError\": false,\n  \"MaximumRetryAttempts\": 0,\n  \"TumblingWindowInSeconds\": 0,\n  \"Topics\": [],\n  \"Queues\": [],\n  \"SourceAccessConfigurations\": [\n    {\n      \"Type\": \"\",\n      \"URI\": \"\"\n    }\n  ],\n  \"SelfManagedEventSource\": {\n    \"Endpoints\": \"\"\n  },\n  \"FunctionResponseTypes\": [],\n  \"AmazonManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"SelfManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"ScalingConfig\": {\n    \"MaximumConcurrency\": \"\"\n  },\n  \"DocumentDBEventSourceConfig\": {\n    \"DatabaseName\": \"\",\n    \"CollectionName\": \"\",\n    \"FullDocument\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-03-31/event-source-mappings/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/2015-03-31/event-source-mappings/")
  .header("content-type", "application/json")
  .body("{\n  \"EventSourceArn\": \"\",\n  \"FunctionName\": \"\",\n  \"Enabled\": false,\n  \"BatchSize\": 0,\n  \"FilterCriteria\": {\n    \"Filters\": \"\"\n  },\n  \"MaximumBatchingWindowInSeconds\": 0,\n  \"ParallelizationFactor\": 0,\n  \"StartingPosition\": \"\",\n  \"StartingPositionTimestamp\": \"\",\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\n  },\n  \"MaximumRecordAgeInSeconds\": 0,\n  \"BisectBatchOnFunctionError\": false,\n  \"MaximumRetryAttempts\": 0,\n  \"TumblingWindowInSeconds\": 0,\n  \"Topics\": [],\n  \"Queues\": [],\n  \"SourceAccessConfigurations\": [\n    {\n      \"Type\": \"\",\n      \"URI\": \"\"\n    }\n  ],\n  \"SelfManagedEventSource\": {\n    \"Endpoints\": \"\"\n  },\n  \"FunctionResponseTypes\": [],\n  \"AmazonManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"SelfManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"ScalingConfig\": {\n    \"MaximumConcurrency\": \"\"\n  },\n  \"DocumentDBEventSourceConfig\": {\n    \"DatabaseName\": \"\",\n    \"CollectionName\": \"\",\n    \"FullDocument\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  EventSourceArn: '',
  FunctionName: '',
  Enabled: false,
  BatchSize: 0,
  FilterCriteria: {
    Filters: ''
  },
  MaximumBatchingWindowInSeconds: 0,
  ParallelizationFactor: 0,
  StartingPosition: '',
  StartingPositionTimestamp: '',
  DestinationConfig: {
    OnSuccess: '',
    OnFailure: ''
  },
  MaximumRecordAgeInSeconds: 0,
  BisectBatchOnFunctionError: false,
  MaximumRetryAttempts: 0,
  TumblingWindowInSeconds: 0,
  Topics: [],
  Queues: [],
  SourceAccessConfigurations: [
    {
      Type: '',
      URI: ''
    }
  ],
  SelfManagedEventSource: {
    Endpoints: ''
  },
  FunctionResponseTypes: [],
  AmazonManagedKafkaEventSourceConfig: {
    ConsumerGroupId: ''
  },
  SelfManagedKafkaEventSourceConfig: {
    ConsumerGroupId: ''
  },
  ScalingConfig: {
    MaximumConcurrency: ''
  },
  DocumentDBEventSourceConfig: {
    DatabaseName: '',
    CollectionName: '',
    FullDocument: ''
  }
});

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

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

xhr.open('POST', '{{baseUrl}}/2015-03-31/event-source-mappings/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-03-31/event-source-mappings/',
  headers: {'content-type': 'application/json'},
  data: {
    EventSourceArn: '',
    FunctionName: '',
    Enabled: false,
    BatchSize: 0,
    FilterCriteria: {Filters: ''},
    MaximumBatchingWindowInSeconds: 0,
    ParallelizationFactor: 0,
    StartingPosition: '',
    StartingPositionTimestamp: '',
    DestinationConfig: {OnSuccess: '', OnFailure: ''},
    MaximumRecordAgeInSeconds: 0,
    BisectBatchOnFunctionError: false,
    MaximumRetryAttempts: 0,
    TumblingWindowInSeconds: 0,
    Topics: [],
    Queues: [],
    SourceAccessConfigurations: [{Type: '', URI: ''}],
    SelfManagedEventSource: {Endpoints: ''},
    FunctionResponseTypes: [],
    AmazonManagedKafkaEventSourceConfig: {ConsumerGroupId: ''},
    SelfManagedKafkaEventSourceConfig: {ConsumerGroupId: ''},
    ScalingConfig: {MaximumConcurrency: ''},
    DocumentDBEventSourceConfig: {DatabaseName: '', CollectionName: '', FullDocument: ''}
  }
};

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

const url = '{{baseUrl}}/2015-03-31/event-source-mappings/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"EventSourceArn":"","FunctionName":"","Enabled":false,"BatchSize":0,"FilterCriteria":{"Filters":""},"MaximumBatchingWindowInSeconds":0,"ParallelizationFactor":0,"StartingPosition":"","StartingPositionTimestamp":"","DestinationConfig":{"OnSuccess":"","OnFailure":""},"MaximumRecordAgeInSeconds":0,"BisectBatchOnFunctionError":false,"MaximumRetryAttempts":0,"TumblingWindowInSeconds":0,"Topics":[],"Queues":[],"SourceAccessConfigurations":[{"Type":"","URI":""}],"SelfManagedEventSource":{"Endpoints":""},"FunctionResponseTypes":[],"AmazonManagedKafkaEventSourceConfig":{"ConsumerGroupId":""},"SelfManagedKafkaEventSourceConfig":{"ConsumerGroupId":""},"ScalingConfig":{"MaximumConcurrency":""},"DocumentDBEventSourceConfig":{"DatabaseName":"","CollectionName":"","FullDocument":""}}'
};

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}}/2015-03-31/event-source-mappings/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "EventSourceArn": "",\n  "FunctionName": "",\n  "Enabled": false,\n  "BatchSize": 0,\n  "FilterCriteria": {\n    "Filters": ""\n  },\n  "MaximumBatchingWindowInSeconds": 0,\n  "ParallelizationFactor": 0,\n  "StartingPosition": "",\n  "StartingPositionTimestamp": "",\n  "DestinationConfig": {\n    "OnSuccess": "",\n    "OnFailure": ""\n  },\n  "MaximumRecordAgeInSeconds": 0,\n  "BisectBatchOnFunctionError": false,\n  "MaximumRetryAttempts": 0,\n  "TumblingWindowInSeconds": 0,\n  "Topics": [],\n  "Queues": [],\n  "SourceAccessConfigurations": [\n    {\n      "Type": "",\n      "URI": ""\n    }\n  ],\n  "SelfManagedEventSource": {\n    "Endpoints": ""\n  },\n  "FunctionResponseTypes": [],\n  "AmazonManagedKafkaEventSourceConfig": {\n    "ConsumerGroupId": ""\n  },\n  "SelfManagedKafkaEventSourceConfig": {\n    "ConsumerGroupId": ""\n  },\n  "ScalingConfig": {\n    "MaximumConcurrency": ""\n  },\n  "DocumentDBEventSourceConfig": {\n    "DatabaseName": "",\n    "CollectionName": "",\n    "FullDocument": ""\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  \"EventSourceArn\": \"\",\n  \"FunctionName\": \"\",\n  \"Enabled\": false,\n  \"BatchSize\": 0,\n  \"FilterCriteria\": {\n    \"Filters\": \"\"\n  },\n  \"MaximumBatchingWindowInSeconds\": 0,\n  \"ParallelizationFactor\": 0,\n  \"StartingPosition\": \"\",\n  \"StartingPositionTimestamp\": \"\",\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\n  },\n  \"MaximumRecordAgeInSeconds\": 0,\n  \"BisectBatchOnFunctionError\": false,\n  \"MaximumRetryAttempts\": 0,\n  \"TumblingWindowInSeconds\": 0,\n  \"Topics\": [],\n  \"Queues\": [],\n  \"SourceAccessConfigurations\": [\n    {\n      \"Type\": \"\",\n      \"URI\": \"\"\n    }\n  ],\n  \"SelfManagedEventSource\": {\n    \"Endpoints\": \"\"\n  },\n  \"FunctionResponseTypes\": [],\n  \"AmazonManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"SelfManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"ScalingConfig\": {\n    \"MaximumConcurrency\": \"\"\n  },\n  \"DocumentDBEventSourceConfig\": {\n    \"DatabaseName\": \"\",\n    \"CollectionName\": \"\",\n    \"FullDocument\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2015-03-31/event-source-mappings/")
  .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/2015-03-31/event-source-mappings/',
  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({
  EventSourceArn: '',
  FunctionName: '',
  Enabled: false,
  BatchSize: 0,
  FilterCriteria: {Filters: ''},
  MaximumBatchingWindowInSeconds: 0,
  ParallelizationFactor: 0,
  StartingPosition: '',
  StartingPositionTimestamp: '',
  DestinationConfig: {OnSuccess: '', OnFailure: ''},
  MaximumRecordAgeInSeconds: 0,
  BisectBatchOnFunctionError: false,
  MaximumRetryAttempts: 0,
  TumblingWindowInSeconds: 0,
  Topics: [],
  Queues: [],
  SourceAccessConfigurations: [{Type: '', URI: ''}],
  SelfManagedEventSource: {Endpoints: ''},
  FunctionResponseTypes: [],
  AmazonManagedKafkaEventSourceConfig: {ConsumerGroupId: ''},
  SelfManagedKafkaEventSourceConfig: {ConsumerGroupId: ''},
  ScalingConfig: {MaximumConcurrency: ''},
  DocumentDBEventSourceConfig: {DatabaseName: '', CollectionName: '', FullDocument: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-03-31/event-source-mappings/',
  headers: {'content-type': 'application/json'},
  body: {
    EventSourceArn: '',
    FunctionName: '',
    Enabled: false,
    BatchSize: 0,
    FilterCriteria: {Filters: ''},
    MaximumBatchingWindowInSeconds: 0,
    ParallelizationFactor: 0,
    StartingPosition: '',
    StartingPositionTimestamp: '',
    DestinationConfig: {OnSuccess: '', OnFailure: ''},
    MaximumRecordAgeInSeconds: 0,
    BisectBatchOnFunctionError: false,
    MaximumRetryAttempts: 0,
    TumblingWindowInSeconds: 0,
    Topics: [],
    Queues: [],
    SourceAccessConfigurations: [{Type: '', URI: ''}],
    SelfManagedEventSource: {Endpoints: ''},
    FunctionResponseTypes: [],
    AmazonManagedKafkaEventSourceConfig: {ConsumerGroupId: ''},
    SelfManagedKafkaEventSourceConfig: {ConsumerGroupId: ''},
    ScalingConfig: {MaximumConcurrency: ''},
    DocumentDBEventSourceConfig: {DatabaseName: '', CollectionName: '', FullDocument: ''}
  },
  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}}/2015-03-31/event-source-mappings/');

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

req.type('json');
req.send({
  EventSourceArn: '',
  FunctionName: '',
  Enabled: false,
  BatchSize: 0,
  FilterCriteria: {
    Filters: ''
  },
  MaximumBatchingWindowInSeconds: 0,
  ParallelizationFactor: 0,
  StartingPosition: '',
  StartingPositionTimestamp: '',
  DestinationConfig: {
    OnSuccess: '',
    OnFailure: ''
  },
  MaximumRecordAgeInSeconds: 0,
  BisectBatchOnFunctionError: false,
  MaximumRetryAttempts: 0,
  TumblingWindowInSeconds: 0,
  Topics: [],
  Queues: [],
  SourceAccessConfigurations: [
    {
      Type: '',
      URI: ''
    }
  ],
  SelfManagedEventSource: {
    Endpoints: ''
  },
  FunctionResponseTypes: [],
  AmazonManagedKafkaEventSourceConfig: {
    ConsumerGroupId: ''
  },
  SelfManagedKafkaEventSourceConfig: {
    ConsumerGroupId: ''
  },
  ScalingConfig: {
    MaximumConcurrency: ''
  },
  DocumentDBEventSourceConfig: {
    DatabaseName: '',
    CollectionName: '',
    FullDocument: ''
  }
});

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}}/2015-03-31/event-source-mappings/',
  headers: {'content-type': 'application/json'},
  data: {
    EventSourceArn: '',
    FunctionName: '',
    Enabled: false,
    BatchSize: 0,
    FilterCriteria: {Filters: ''},
    MaximumBatchingWindowInSeconds: 0,
    ParallelizationFactor: 0,
    StartingPosition: '',
    StartingPositionTimestamp: '',
    DestinationConfig: {OnSuccess: '', OnFailure: ''},
    MaximumRecordAgeInSeconds: 0,
    BisectBatchOnFunctionError: false,
    MaximumRetryAttempts: 0,
    TumblingWindowInSeconds: 0,
    Topics: [],
    Queues: [],
    SourceAccessConfigurations: [{Type: '', URI: ''}],
    SelfManagedEventSource: {Endpoints: ''},
    FunctionResponseTypes: [],
    AmazonManagedKafkaEventSourceConfig: {ConsumerGroupId: ''},
    SelfManagedKafkaEventSourceConfig: {ConsumerGroupId: ''},
    ScalingConfig: {MaximumConcurrency: ''},
    DocumentDBEventSourceConfig: {DatabaseName: '', CollectionName: '', FullDocument: ''}
  }
};

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

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

const url = '{{baseUrl}}/2015-03-31/event-source-mappings/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"EventSourceArn":"","FunctionName":"","Enabled":false,"BatchSize":0,"FilterCriteria":{"Filters":""},"MaximumBatchingWindowInSeconds":0,"ParallelizationFactor":0,"StartingPosition":"","StartingPositionTimestamp":"","DestinationConfig":{"OnSuccess":"","OnFailure":""},"MaximumRecordAgeInSeconds":0,"BisectBatchOnFunctionError":false,"MaximumRetryAttempts":0,"TumblingWindowInSeconds":0,"Topics":[],"Queues":[],"SourceAccessConfigurations":[{"Type":"","URI":""}],"SelfManagedEventSource":{"Endpoints":""},"FunctionResponseTypes":[],"AmazonManagedKafkaEventSourceConfig":{"ConsumerGroupId":""},"SelfManagedKafkaEventSourceConfig":{"ConsumerGroupId":""},"ScalingConfig":{"MaximumConcurrency":""},"DocumentDBEventSourceConfig":{"DatabaseName":"","CollectionName":"","FullDocument":""}}'
};

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 = @{ @"EventSourceArn": @"",
                              @"FunctionName": @"",
                              @"Enabled": @NO,
                              @"BatchSize": @0,
                              @"FilterCriteria": @{ @"Filters": @"" },
                              @"MaximumBatchingWindowInSeconds": @0,
                              @"ParallelizationFactor": @0,
                              @"StartingPosition": @"",
                              @"StartingPositionTimestamp": @"",
                              @"DestinationConfig": @{ @"OnSuccess": @"", @"OnFailure": @"" },
                              @"MaximumRecordAgeInSeconds": @0,
                              @"BisectBatchOnFunctionError": @NO,
                              @"MaximumRetryAttempts": @0,
                              @"TumblingWindowInSeconds": @0,
                              @"Topics": @[  ],
                              @"Queues": @[  ],
                              @"SourceAccessConfigurations": @[ @{ @"Type": @"", @"URI": @"" } ],
                              @"SelfManagedEventSource": @{ @"Endpoints": @"" },
                              @"FunctionResponseTypes": @[  ],
                              @"AmazonManagedKafkaEventSourceConfig": @{ @"ConsumerGroupId": @"" },
                              @"SelfManagedKafkaEventSourceConfig": @{ @"ConsumerGroupId": @"" },
                              @"ScalingConfig": @{ @"MaximumConcurrency": @"" },
                              @"DocumentDBEventSourceConfig": @{ @"DatabaseName": @"", @"CollectionName": @"", @"FullDocument": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-03-31/event-source-mappings/"]
                                                       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}}/2015-03-31/event-source-mappings/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"EventSourceArn\": \"\",\n  \"FunctionName\": \"\",\n  \"Enabled\": false,\n  \"BatchSize\": 0,\n  \"FilterCriteria\": {\n    \"Filters\": \"\"\n  },\n  \"MaximumBatchingWindowInSeconds\": 0,\n  \"ParallelizationFactor\": 0,\n  \"StartingPosition\": \"\",\n  \"StartingPositionTimestamp\": \"\",\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\n  },\n  \"MaximumRecordAgeInSeconds\": 0,\n  \"BisectBatchOnFunctionError\": false,\n  \"MaximumRetryAttempts\": 0,\n  \"TumblingWindowInSeconds\": 0,\n  \"Topics\": [],\n  \"Queues\": [],\n  \"SourceAccessConfigurations\": [\n    {\n      \"Type\": \"\",\n      \"URI\": \"\"\n    }\n  ],\n  \"SelfManagedEventSource\": {\n    \"Endpoints\": \"\"\n  },\n  \"FunctionResponseTypes\": [],\n  \"AmazonManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"SelfManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"ScalingConfig\": {\n    \"MaximumConcurrency\": \"\"\n  },\n  \"DocumentDBEventSourceConfig\": {\n    \"DatabaseName\": \"\",\n    \"CollectionName\": \"\",\n    \"FullDocument\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/2015-03-31/event-source-mappings/",
  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([
    'EventSourceArn' => '',
    'FunctionName' => '',
    'Enabled' => null,
    'BatchSize' => 0,
    'FilterCriteria' => [
        'Filters' => ''
    ],
    'MaximumBatchingWindowInSeconds' => 0,
    'ParallelizationFactor' => 0,
    'StartingPosition' => '',
    'StartingPositionTimestamp' => '',
    'DestinationConfig' => [
        'OnSuccess' => '',
        'OnFailure' => ''
    ],
    'MaximumRecordAgeInSeconds' => 0,
    'BisectBatchOnFunctionError' => null,
    'MaximumRetryAttempts' => 0,
    'TumblingWindowInSeconds' => 0,
    'Topics' => [
        
    ],
    'Queues' => [
        
    ],
    'SourceAccessConfigurations' => [
        [
                'Type' => '',
                'URI' => ''
        ]
    ],
    'SelfManagedEventSource' => [
        'Endpoints' => ''
    ],
    'FunctionResponseTypes' => [
        
    ],
    'AmazonManagedKafkaEventSourceConfig' => [
        'ConsumerGroupId' => ''
    ],
    'SelfManagedKafkaEventSourceConfig' => [
        'ConsumerGroupId' => ''
    ],
    'ScalingConfig' => [
        'MaximumConcurrency' => ''
    ],
    'DocumentDBEventSourceConfig' => [
        'DatabaseName' => '',
        'CollectionName' => '',
        'FullDocument' => ''
    ]
  ]),
  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}}/2015-03-31/event-source-mappings/', [
  'body' => '{
  "EventSourceArn": "",
  "FunctionName": "",
  "Enabled": false,
  "BatchSize": 0,
  "FilterCriteria": {
    "Filters": ""
  },
  "MaximumBatchingWindowInSeconds": 0,
  "ParallelizationFactor": 0,
  "StartingPosition": "",
  "StartingPositionTimestamp": "",
  "DestinationConfig": {
    "OnSuccess": "",
    "OnFailure": ""
  },
  "MaximumRecordAgeInSeconds": 0,
  "BisectBatchOnFunctionError": false,
  "MaximumRetryAttempts": 0,
  "TumblingWindowInSeconds": 0,
  "Topics": [],
  "Queues": [],
  "SourceAccessConfigurations": [
    {
      "Type": "",
      "URI": ""
    }
  ],
  "SelfManagedEventSource": {
    "Endpoints": ""
  },
  "FunctionResponseTypes": [],
  "AmazonManagedKafkaEventSourceConfig": {
    "ConsumerGroupId": ""
  },
  "SelfManagedKafkaEventSourceConfig": {
    "ConsumerGroupId": ""
  },
  "ScalingConfig": {
    "MaximumConcurrency": ""
  },
  "DocumentDBEventSourceConfig": {
    "DatabaseName": "",
    "CollectionName": "",
    "FullDocument": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2015-03-31/event-source-mappings/');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'EventSourceArn' => '',
  'FunctionName' => '',
  'Enabled' => null,
  'BatchSize' => 0,
  'FilterCriteria' => [
    'Filters' => ''
  ],
  'MaximumBatchingWindowInSeconds' => 0,
  'ParallelizationFactor' => 0,
  'StartingPosition' => '',
  'StartingPositionTimestamp' => '',
  'DestinationConfig' => [
    'OnSuccess' => '',
    'OnFailure' => ''
  ],
  'MaximumRecordAgeInSeconds' => 0,
  'BisectBatchOnFunctionError' => null,
  'MaximumRetryAttempts' => 0,
  'TumblingWindowInSeconds' => 0,
  'Topics' => [
    
  ],
  'Queues' => [
    
  ],
  'SourceAccessConfigurations' => [
    [
        'Type' => '',
        'URI' => ''
    ]
  ],
  'SelfManagedEventSource' => [
    'Endpoints' => ''
  ],
  'FunctionResponseTypes' => [
    
  ],
  'AmazonManagedKafkaEventSourceConfig' => [
    'ConsumerGroupId' => ''
  ],
  'SelfManagedKafkaEventSourceConfig' => [
    'ConsumerGroupId' => ''
  ],
  'ScalingConfig' => [
    'MaximumConcurrency' => ''
  ],
  'DocumentDBEventSourceConfig' => [
    'DatabaseName' => '',
    'CollectionName' => '',
    'FullDocument' => ''
  ]
]));

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

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

append(json_encode([
  'EventSourceArn' => '',
  'FunctionName' => '',
  'Enabled' => null,
  'BatchSize' => 0,
  'FilterCriteria' => [
    'Filters' => ''
  ],
  'MaximumBatchingWindowInSeconds' => 0,
  'ParallelizationFactor' => 0,
  'StartingPosition' => '',
  'StartingPositionTimestamp' => '',
  'DestinationConfig' => [
    'OnSuccess' => '',
    'OnFailure' => ''
  ],
  'MaximumRecordAgeInSeconds' => 0,
  'BisectBatchOnFunctionError' => null,
  'MaximumRetryAttempts' => 0,
  'TumblingWindowInSeconds' => 0,
  'Topics' => [
    
  ],
  'Queues' => [
    
  ],
  'SourceAccessConfigurations' => [
    [
        'Type' => '',
        'URI' => ''
    ]
  ],
  'SelfManagedEventSource' => [
    'Endpoints' => ''
  ],
  'FunctionResponseTypes' => [
    
  ],
  'AmazonManagedKafkaEventSourceConfig' => [
    'ConsumerGroupId' => ''
  ],
  'SelfManagedKafkaEventSourceConfig' => [
    'ConsumerGroupId' => ''
  ],
  'ScalingConfig' => [
    'MaximumConcurrency' => ''
  ],
  'DocumentDBEventSourceConfig' => [
    'DatabaseName' => '',
    'CollectionName' => '',
    'FullDocument' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/2015-03-31/event-source-mappings/');
$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}}/2015-03-31/event-source-mappings/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EventSourceArn": "",
  "FunctionName": "",
  "Enabled": false,
  "BatchSize": 0,
  "FilterCriteria": {
    "Filters": ""
  },
  "MaximumBatchingWindowInSeconds": 0,
  "ParallelizationFactor": 0,
  "StartingPosition": "",
  "StartingPositionTimestamp": "",
  "DestinationConfig": {
    "OnSuccess": "",
    "OnFailure": ""
  },
  "MaximumRecordAgeInSeconds": 0,
  "BisectBatchOnFunctionError": false,
  "MaximumRetryAttempts": 0,
  "TumblingWindowInSeconds": 0,
  "Topics": [],
  "Queues": [],
  "SourceAccessConfigurations": [
    {
      "Type": "",
      "URI": ""
    }
  ],
  "SelfManagedEventSource": {
    "Endpoints": ""
  },
  "FunctionResponseTypes": [],
  "AmazonManagedKafkaEventSourceConfig": {
    "ConsumerGroupId": ""
  },
  "SelfManagedKafkaEventSourceConfig": {
    "ConsumerGroupId": ""
  },
  "ScalingConfig": {
    "MaximumConcurrency": ""
  },
  "DocumentDBEventSourceConfig": {
    "DatabaseName": "",
    "CollectionName": "",
    "FullDocument": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-03-31/event-source-mappings/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EventSourceArn": "",
  "FunctionName": "",
  "Enabled": false,
  "BatchSize": 0,
  "FilterCriteria": {
    "Filters": ""
  },
  "MaximumBatchingWindowInSeconds": 0,
  "ParallelizationFactor": 0,
  "StartingPosition": "",
  "StartingPositionTimestamp": "",
  "DestinationConfig": {
    "OnSuccess": "",
    "OnFailure": ""
  },
  "MaximumRecordAgeInSeconds": 0,
  "BisectBatchOnFunctionError": false,
  "MaximumRetryAttempts": 0,
  "TumblingWindowInSeconds": 0,
  "Topics": [],
  "Queues": [],
  "SourceAccessConfigurations": [
    {
      "Type": "",
      "URI": ""
    }
  ],
  "SelfManagedEventSource": {
    "Endpoints": ""
  },
  "FunctionResponseTypes": [],
  "AmazonManagedKafkaEventSourceConfig": {
    "ConsumerGroupId": ""
  },
  "SelfManagedKafkaEventSourceConfig": {
    "ConsumerGroupId": ""
  },
  "ScalingConfig": {
    "MaximumConcurrency": ""
  },
  "DocumentDBEventSourceConfig": {
    "DatabaseName": "",
    "CollectionName": "",
    "FullDocument": ""
  }
}'

import http.client

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

payload = "{\n  \"EventSourceArn\": \"\",\n  \"FunctionName\": \"\",\n  \"Enabled\": false,\n  \"BatchSize\": 0,\n  \"FilterCriteria\": {\n    \"Filters\": \"\"\n  },\n  \"MaximumBatchingWindowInSeconds\": 0,\n  \"ParallelizationFactor\": 0,\n  \"StartingPosition\": \"\",\n  \"StartingPositionTimestamp\": \"\",\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\n  },\n  \"MaximumRecordAgeInSeconds\": 0,\n  \"BisectBatchOnFunctionError\": false,\n  \"MaximumRetryAttempts\": 0,\n  \"TumblingWindowInSeconds\": 0,\n  \"Topics\": [],\n  \"Queues\": [],\n  \"SourceAccessConfigurations\": [\n    {\n      \"Type\": \"\",\n      \"URI\": \"\"\n    }\n  ],\n  \"SelfManagedEventSource\": {\n    \"Endpoints\": \"\"\n  },\n  \"FunctionResponseTypes\": [],\n  \"AmazonManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"SelfManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"ScalingConfig\": {\n    \"MaximumConcurrency\": \"\"\n  },\n  \"DocumentDBEventSourceConfig\": {\n    \"DatabaseName\": \"\",\n    \"CollectionName\": \"\",\n    \"FullDocument\": \"\"\n  }\n}"

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

conn.request("POST", "/baseUrl/2015-03-31/event-source-mappings/", payload, headers)

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

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

import requests

url = "{{baseUrl}}/2015-03-31/event-source-mappings/"

payload = {
    "EventSourceArn": "",
    "FunctionName": "",
    "Enabled": False,
    "BatchSize": 0,
    "FilterCriteria": { "Filters": "" },
    "MaximumBatchingWindowInSeconds": 0,
    "ParallelizationFactor": 0,
    "StartingPosition": "",
    "StartingPositionTimestamp": "",
    "DestinationConfig": {
        "OnSuccess": "",
        "OnFailure": ""
    },
    "MaximumRecordAgeInSeconds": 0,
    "BisectBatchOnFunctionError": False,
    "MaximumRetryAttempts": 0,
    "TumblingWindowInSeconds": 0,
    "Topics": [],
    "Queues": [],
    "SourceAccessConfigurations": [
        {
            "Type": "",
            "URI": ""
        }
    ],
    "SelfManagedEventSource": { "Endpoints": "" },
    "FunctionResponseTypes": [],
    "AmazonManagedKafkaEventSourceConfig": { "ConsumerGroupId": "" },
    "SelfManagedKafkaEventSourceConfig": { "ConsumerGroupId": "" },
    "ScalingConfig": { "MaximumConcurrency": "" },
    "DocumentDBEventSourceConfig": {
        "DatabaseName": "",
        "CollectionName": "",
        "FullDocument": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-03-31/event-source-mappings/"

payload <- "{\n  \"EventSourceArn\": \"\",\n  \"FunctionName\": \"\",\n  \"Enabled\": false,\n  \"BatchSize\": 0,\n  \"FilterCriteria\": {\n    \"Filters\": \"\"\n  },\n  \"MaximumBatchingWindowInSeconds\": 0,\n  \"ParallelizationFactor\": 0,\n  \"StartingPosition\": \"\",\n  \"StartingPositionTimestamp\": \"\",\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\n  },\n  \"MaximumRecordAgeInSeconds\": 0,\n  \"BisectBatchOnFunctionError\": false,\n  \"MaximumRetryAttempts\": 0,\n  \"TumblingWindowInSeconds\": 0,\n  \"Topics\": [],\n  \"Queues\": [],\n  \"SourceAccessConfigurations\": [\n    {\n      \"Type\": \"\",\n      \"URI\": \"\"\n    }\n  ],\n  \"SelfManagedEventSource\": {\n    \"Endpoints\": \"\"\n  },\n  \"FunctionResponseTypes\": [],\n  \"AmazonManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"SelfManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"ScalingConfig\": {\n    \"MaximumConcurrency\": \"\"\n  },\n  \"DocumentDBEventSourceConfig\": {\n    \"DatabaseName\": \"\",\n    \"CollectionName\": \"\",\n    \"FullDocument\": \"\"\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}}/2015-03-31/event-source-mappings/")

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  \"EventSourceArn\": \"\",\n  \"FunctionName\": \"\",\n  \"Enabled\": false,\n  \"BatchSize\": 0,\n  \"FilterCriteria\": {\n    \"Filters\": \"\"\n  },\n  \"MaximumBatchingWindowInSeconds\": 0,\n  \"ParallelizationFactor\": 0,\n  \"StartingPosition\": \"\",\n  \"StartingPositionTimestamp\": \"\",\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\n  },\n  \"MaximumRecordAgeInSeconds\": 0,\n  \"BisectBatchOnFunctionError\": false,\n  \"MaximumRetryAttempts\": 0,\n  \"TumblingWindowInSeconds\": 0,\n  \"Topics\": [],\n  \"Queues\": [],\n  \"SourceAccessConfigurations\": [\n    {\n      \"Type\": \"\",\n      \"URI\": \"\"\n    }\n  ],\n  \"SelfManagedEventSource\": {\n    \"Endpoints\": \"\"\n  },\n  \"FunctionResponseTypes\": [],\n  \"AmazonManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"SelfManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"ScalingConfig\": {\n    \"MaximumConcurrency\": \"\"\n  },\n  \"DocumentDBEventSourceConfig\": {\n    \"DatabaseName\": \"\",\n    \"CollectionName\": \"\",\n    \"FullDocument\": \"\"\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/2015-03-31/event-source-mappings/') do |req|
  req.body = "{\n  \"EventSourceArn\": \"\",\n  \"FunctionName\": \"\",\n  \"Enabled\": false,\n  \"BatchSize\": 0,\n  \"FilterCriteria\": {\n    \"Filters\": \"\"\n  },\n  \"MaximumBatchingWindowInSeconds\": 0,\n  \"ParallelizationFactor\": 0,\n  \"StartingPosition\": \"\",\n  \"StartingPositionTimestamp\": \"\",\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\n  },\n  \"MaximumRecordAgeInSeconds\": 0,\n  \"BisectBatchOnFunctionError\": false,\n  \"MaximumRetryAttempts\": 0,\n  \"TumblingWindowInSeconds\": 0,\n  \"Topics\": [],\n  \"Queues\": [],\n  \"SourceAccessConfigurations\": [\n    {\n      \"Type\": \"\",\n      \"URI\": \"\"\n    }\n  ],\n  \"SelfManagedEventSource\": {\n    \"Endpoints\": \"\"\n  },\n  \"FunctionResponseTypes\": [],\n  \"AmazonManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"SelfManagedKafkaEventSourceConfig\": {\n    \"ConsumerGroupId\": \"\"\n  },\n  \"ScalingConfig\": {\n    \"MaximumConcurrency\": \"\"\n  },\n  \"DocumentDBEventSourceConfig\": {\n    \"DatabaseName\": \"\",\n    \"CollectionName\": \"\",\n    \"FullDocument\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-03-31/event-source-mappings/";

    let payload = json!({
        "EventSourceArn": "",
        "FunctionName": "",
        "Enabled": false,
        "BatchSize": 0,
        "FilterCriteria": json!({"Filters": ""}),
        "MaximumBatchingWindowInSeconds": 0,
        "ParallelizationFactor": 0,
        "StartingPosition": "",
        "StartingPositionTimestamp": "",
        "DestinationConfig": json!({
            "OnSuccess": "",
            "OnFailure": ""
        }),
        "MaximumRecordAgeInSeconds": 0,
        "BisectBatchOnFunctionError": false,
        "MaximumRetryAttempts": 0,
        "TumblingWindowInSeconds": 0,
        "Topics": (),
        "Queues": (),
        "SourceAccessConfigurations": (
            json!({
                "Type": "",
                "URI": ""
            })
        ),
        "SelfManagedEventSource": json!({"Endpoints": ""}),
        "FunctionResponseTypes": (),
        "AmazonManagedKafkaEventSourceConfig": json!({"ConsumerGroupId": ""}),
        "SelfManagedKafkaEventSourceConfig": json!({"ConsumerGroupId": ""}),
        "ScalingConfig": json!({"MaximumConcurrency": ""}),
        "DocumentDBEventSourceConfig": json!({
            "DatabaseName": "",
            "CollectionName": "",
            "FullDocument": ""
        })
    });

    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 '{
  "EventSourceArn": "",
  "FunctionName": "",
  "Enabled": false,
  "BatchSize": 0,
  "FilterCriteria": {
    "Filters": ""
  },
  "MaximumBatchingWindowInSeconds": 0,
  "ParallelizationFactor": 0,
  "StartingPosition": "",
  "StartingPositionTimestamp": "",
  "DestinationConfig": {
    "OnSuccess": "",
    "OnFailure": ""
  },
  "MaximumRecordAgeInSeconds": 0,
  "BisectBatchOnFunctionError": false,
  "MaximumRetryAttempts": 0,
  "TumblingWindowInSeconds": 0,
  "Topics": [],
  "Queues": [],
  "SourceAccessConfigurations": [
    {
      "Type": "",
      "URI": ""
    }
  ],
  "SelfManagedEventSource": {
    "Endpoints": ""
  },
  "FunctionResponseTypes": [],
  "AmazonManagedKafkaEventSourceConfig": {
    "ConsumerGroupId": ""
  },
  "SelfManagedKafkaEventSourceConfig": {
    "ConsumerGroupId": ""
  },
  "ScalingConfig": {
    "MaximumConcurrency": ""
  },
  "DocumentDBEventSourceConfig": {
    "DatabaseName": "",
    "CollectionName": "",
    "FullDocument": ""
  }
}' |  \
  http POST {{baseUrl}}/2015-03-31/event-source-mappings/ \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "EventSourceArn": "",\n  "FunctionName": "",\n  "Enabled": false,\n  "BatchSize": 0,\n  "FilterCriteria": {\n    "Filters": ""\n  },\n  "MaximumBatchingWindowInSeconds": 0,\n  "ParallelizationFactor": 0,\n  "StartingPosition": "",\n  "StartingPositionTimestamp": "",\n  "DestinationConfig": {\n    "OnSuccess": "",\n    "OnFailure": ""\n  },\n  "MaximumRecordAgeInSeconds": 0,\n  "BisectBatchOnFunctionError": false,\n  "MaximumRetryAttempts": 0,\n  "TumblingWindowInSeconds": 0,\n  "Topics": [],\n  "Queues": [],\n  "SourceAccessConfigurations": [\n    {\n      "Type": "",\n      "URI": ""\n    }\n  ],\n  "SelfManagedEventSource": {\n    "Endpoints": ""\n  },\n  "FunctionResponseTypes": [],\n  "AmazonManagedKafkaEventSourceConfig": {\n    "ConsumerGroupId": ""\n  },\n  "SelfManagedKafkaEventSourceConfig": {\n    "ConsumerGroupId": ""\n  },\n  "ScalingConfig": {\n    "MaximumConcurrency": ""\n  },\n  "DocumentDBEventSourceConfig": {\n    "DatabaseName": "",\n    "CollectionName": "",\n    "FullDocument": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/2015-03-31/event-source-mappings/

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "EventSourceArn": "",
  "FunctionName": "",
  "Enabled": false,
  "BatchSize": 0,
  "FilterCriteria": ["Filters": ""],
  "MaximumBatchingWindowInSeconds": 0,
  "ParallelizationFactor": 0,
  "StartingPosition": "",
  "StartingPositionTimestamp": "",
  "DestinationConfig": [
    "OnSuccess": "",
    "OnFailure": ""
  ],
  "MaximumRecordAgeInSeconds": 0,
  "BisectBatchOnFunctionError": false,
  "MaximumRetryAttempts": 0,
  "TumblingWindowInSeconds": 0,
  "Topics": [],
  "Queues": [],
  "SourceAccessConfigurations": [
    [
      "Type": "",
      "URI": ""
    ]
  ],
  "SelfManagedEventSource": ["Endpoints": ""],
  "FunctionResponseTypes": [],
  "AmazonManagedKafkaEventSourceConfig": ["ConsumerGroupId": ""],
  "SelfManagedKafkaEventSourceConfig": ["ConsumerGroupId": ""],
  "ScalingConfig": ["MaximumConcurrency": ""],
  "DocumentDBEventSourceConfig": [
    "DatabaseName": "",
    "CollectionName": "",
    "FullDocument": ""
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-03-31/event-source-mappings/")! 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}}/2015-03-31/functions");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"FunctionName\": \"\",\n  \"Runtime\": \"\",\n  \"Role\": \"\",\n  \"Handler\": \"\",\n  \"Code\": {\n    \"ZipFile\": \"\",\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ImageUri\": \"\"\n  },\n  \"Description\": \"\",\n  \"Timeout\": 0,\n  \"MemorySize\": 0,\n  \"Publish\": false,\n  \"VpcConfig\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"PackageType\": \"\",\n  \"DeadLetterConfig\": {\n    \"TargetArn\": \"\"\n  },\n  \"Environment\": {\n    \"Variables\": \"\"\n  },\n  \"KMSKeyArn\": \"\",\n  \"TracingConfig\": {\n    \"Mode\": \"\"\n  },\n  \"Tags\": {},\n  \"Layers\": [],\n  \"FileSystemConfigs\": [\n    {\n      \"Arn\": \"\",\n      \"LocalMountPath\": \"\"\n    }\n  ],\n  \"ImageConfig\": {\n    \"EntryPoint\": \"\",\n    \"Command\": \"\",\n    \"WorkingDirectory\": \"\"\n  },\n  \"CodeSigningConfigArn\": \"\",\n  \"Architectures\": [],\n  \"EphemeralStorage\": {\n    \"Size\": \"\"\n  },\n  \"SnapStart\": {\n    \"ApplyOn\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/2015-03-31/functions" {:content-type :json
                                                                 :form-params {:FunctionName ""
                                                                               :Runtime ""
                                                                               :Role ""
                                                                               :Handler ""
                                                                               :Code {:ZipFile ""
                                                                                      :S3Bucket ""
                                                                                      :S3Key ""
                                                                                      :S3ObjectVersion ""
                                                                                      :ImageUri ""}
                                                                               :Description ""
                                                                               :Timeout 0
                                                                               :MemorySize 0
                                                                               :Publish false
                                                                               :VpcConfig {:SubnetIds ""
                                                                                           :SecurityGroupIds ""}
                                                                               :PackageType ""
                                                                               :DeadLetterConfig {:TargetArn ""}
                                                                               :Environment {:Variables ""}
                                                                               :KMSKeyArn ""
                                                                               :TracingConfig {:Mode ""}
                                                                               :Tags {}
                                                                               :Layers []
                                                                               :FileSystemConfigs [{:Arn ""
                                                                                                    :LocalMountPath ""}]
                                                                               :ImageConfig {:EntryPoint ""
                                                                                             :Command ""
                                                                                             :WorkingDirectory ""}
                                                                               :CodeSigningConfigArn ""
                                                                               :Architectures []
                                                                               :EphemeralStorage {:Size ""}
                                                                               :SnapStart {:ApplyOn ""}}})

require "http/client"

url = "{{baseUrl}}/2015-03-31/functions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"FunctionName\": \"\",\n  \"Runtime\": \"\",\n  \"Role\": \"\",\n  \"Handler\": \"\",\n  \"Code\": {\n    \"ZipFile\": \"\",\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ImageUri\": \"\"\n  },\n  \"Description\": \"\",\n  \"Timeout\": 0,\n  \"MemorySize\": 0,\n  \"Publish\": false,\n  \"VpcConfig\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"PackageType\": \"\",\n  \"DeadLetterConfig\": {\n    \"TargetArn\": \"\"\n  },\n  \"Environment\": {\n    \"Variables\": \"\"\n  },\n  \"KMSKeyArn\": \"\",\n  \"TracingConfig\": {\n    \"Mode\": \"\"\n  },\n  \"Tags\": {},\n  \"Layers\": [],\n  \"FileSystemConfigs\": [\n    {\n      \"Arn\": \"\",\n      \"LocalMountPath\": \"\"\n    }\n  ],\n  \"ImageConfig\": {\n    \"EntryPoint\": \"\",\n    \"Command\": \"\",\n    \"WorkingDirectory\": \"\"\n  },\n  \"CodeSigningConfigArn\": \"\",\n  \"Architectures\": [],\n  \"EphemeralStorage\": {\n    \"Size\": \"\"\n  },\n  \"SnapStart\": {\n    \"ApplyOn\": \"\"\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}}/2015-03-31/functions"),
    Content = new StringContent("{\n  \"FunctionName\": \"\",\n  \"Runtime\": \"\",\n  \"Role\": \"\",\n  \"Handler\": \"\",\n  \"Code\": {\n    \"ZipFile\": \"\",\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ImageUri\": \"\"\n  },\n  \"Description\": \"\",\n  \"Timeout\": 0,\n  \"MemorySize\": 0,\n  \"Publish\": false,\n  \"VpcConfig\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"PackageType\": \"\",\n  \"DeadLetterConfig\": {\n    \"TargetArn\": \"\"\n  },\n  \"Environment\": {\n    \"Variables\": \"\"\n  },\n  \"KMSKeyArn\": \"\",\n  \"TracingConfig\": {\n    \"Mode\": \"\"\n  },\n  \"Tags\": {},\n  \"Layers\": [],\n  \"FileSystemConfigs\": [\n    {\n      \"Arn\": \"\",\n      \"LocalMountPath\": \"\"\n    }\n  ],\n  \"ImageConfig\": {\n    \"EntryPoint\": \"\",\n    \"Command\": \"\",\n    \"WorkingDirectory\": \"\"\n  },\n  \"CodeSigningConfigArn\": \"\",\n  \"Architectures\": [],\n  \"EphemeralStorage\": {\n    \"Size\": \"\"\n  },\n  \"SnapStart\": {\n    \"ApplyOn\": \"\"\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}}/2015-03-31/functions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"FunctionName\": \"\",\n  \"Runtime\": \"\",\n  \"Role\": \"\",\n  \"Handler\": \"\",\n  \"Code\": {\n    \"ZipFile\": \"\",\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ImageUri\": \"\"\n  },\n  \"Description\": \"\",\n  \"Timeout\": 0,\n  \"MemorySize\": 0,\n  \"Publish\": false,\n  \"VpcConfig\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"PackageType\": \"\",\n  \"DeadLetterConfig\": {\n    \"TargetArn\": \"\"\n  },\n  \"Environment\": {\n    \"Variables\": \"\"\n  },\n  \"KMSKeyArn\": \"\",\n  \"TracingConfig\": {\n    \"Mode\": \"\"\n  },\n  \"Tags\": {},\n  \"Layers\": [],\n  \"FileSystemConfigs\": [\n    {\n      \"Arn\": \"\",\n      \"LocalMountPath\": \"\"\n    }\n  ],\n  \"ImageConfig\": {\n    \"EntryPoint\": \"\",\n    \"Command\": \"\",\n    \"WorkingDirectory\": \"\"\n  },\n  \"CodeSigningConfigArn\": \"\",\n  \"Architectures\": [],\n  \"EphemeralStorage\": {\n    \"Size\": \"\"\n  },\n  \"SnapStart\": {\n    \"ApplyOn\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-03-31/functions"

	payload := strings.NewReader("{\n  \"FunctionName\": \"\",\n  \"Runtime\": \"\",\n  \"Role\": \"\",\n  \"Handler\": \"\",\n  \"Code\": {\n    \"ZipFile\": \"\",\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ImageUri\": \"\"\n  },\n  \"Description\": \"\",\n  \"Timeout\": 0,\n  \"MemorySize\": 0,\n  \"Publish\": false,\n  \"VpcConfig\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"PackageType\": \"\",\n  \"DeadLetterConfig\": {\n    \"TargetArn\": \"\"\n  },\n  \"Environment\": {\n    \"Variables\": \"\"\n  },\n  \"KMSKeyArn\": \"\",\n  \"TracingConfig\": {\n    \"Mode\": \"\"\n  },\n  \"Tags\": {},\n  \"Layers\": [],\n  \"FileSystemConfigs\": [\n    {\n      \"Arn\": \"\",\n      \"LocalMountPath\": \"\"\n    }\n  ],\n  \"ImageConfig\": {\n    \"EntryPoint\": \"\",\n    \"Command\": \"\",\n    \"WorkingDirectory\": \"\"\n  },\n  \"CodeSigningConfigArn\": \"\",\n  \"Architectures\": [],\n  \"EphemeralStorage\": {\n    \"Size\": \"\"\n  },\n  \"SnapStart\": {\n    \"ApplyOn\": \"\"\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/2015-03-31/functions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 856

{
  "FunctionName": "",
  "Runtime": "",
  "Role": "",
  "Handler": "",
  "Code": {
    "ZipFile": "",
    "S3Bucket": "",
    "S3Key": "",
    "S3ObjectVersion": "",
    "ImageUri": ""
  },
  "Description": "",
  "Timeout": 0,
  "MemorySize": 0,
  "Publish": false,
  "VpcConfig": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  },
  "PackageType": "",
  "DeadLetterConfig": {
    "TargetArn": ""
  },
  "Environment": {
    "Variables": ""
  },
  "KMSKeyArn": "",
  "TracingConfig": {
    "Mode": ""
  },
  "Tags": {},
  "Layers": [],
  "FileSystemConfigs": [
    {
      "Arn": "",
      "LocalMountPath": ""
    }
  ],
  "ImageConfig": {
    "EntryPoint": "",
    "Command": "",
    "WorkingDirectory": ""
  },
  "CodeSigningConfigArn": "",
  "Architectures": [],
  "EphemeralStorage": {
    "Size": ""
  },
  "SnapStart": {
    "ApplyOn": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-03-31/functions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"FunctionName\": \"\",\n  \"Runtime\": \"\",\n  \"Role\": \"\",\n  \"Handler\": \"\",\n  \"Code\": {\n    \"ZipFile\": \"\",\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ImageUri\": \"\"\n  },\n  \"Description\": \"\",\n  \"Timeout\": 0,\n  \"MemorySize\": 0,\n  \"Publish\": false,\n  \"VpcConfig\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"PackageType\": \"\",\n  \"DeadLetterConfig\": {\n    \"TargetArn\": \"\"\n  },\n  \"Environment\": {\n    \"Variables\": \"\"\n  },\n  \"KMSKeyArn\": \"\",\n  \"TracingConfig\": {\n    \"Mode\": \"\"\n  },\n  \"Tags\": {},\n  \"Layers\": [],\n  \"FileSystemConfigs\": [\n    {\n      \"Arn\": \"\",\n      \"LocalMountPath\": \"\"\n    }\n  ],\n  \"ImageConfig\": {\n    \"EntryPoint\": \"\",\n    \"Command\": \"\",\n    \"WorkingDirectory\": \"\"\n  },\n  \"CodeSigningConfigArn\": \"\",\n  \"Architectures\": [],\n  \"EphemeralStorage\": {\n    \"Size\": \"\"\n  },\n  \"SnapStart\": {\n    \"ApplyOn\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-03-31/functions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"FunctionName\": \"\",\n  \"Runtime\": \"\",\n  \"Role\": \"\",\n  \"Handler\": \"\",\n  \"Code\": {\n    \"ZipFile\": \"\",\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ImageUri\": \"\"\n  },\n  \"Description\": \"\",\n  \"Timeout\": 0,\n  \"MemorySize\": 0,\n  \"Publish\": false,\n  \"VpcConfig\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"PackageType\": \"\",\n  \"DeadLetterConfig\": {\n    \"TargetArn\": \"\"\n  },\n  \"Environment\": {\n    \"Variables\": \"\"\n  },\n  \"KMSKeyArn\": \"\",\n  \"TracingConfig\": {\n    \"Mode\": \"\"\n  },\n  \"Tags\": {},\n  \"Layers\": [],\n  \"FileSystemConfigs\": [\n    {\n      \"Arn\": \"\",\n      \"LocalMountPath\": \"\"\n    }\n  ],\n  \"ImageConfig\": {\n    \"EntryPoint\": \"\",\n    \"Command\": \"\",\n    \"WorkingDirectory\": \"\"\n  },\n  \"CodeSigningConfigArn\": \"\",\n  \"Architectures\": [],\n  \"EphemeralStorage\": {\n    \"Size\": \"\"\n  },\n  \"SnapStart\": {\n    \"ApplyOn\": \"\"\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  \"FunctionName\": \"\",\n  \"Runtime\": \"\",\n  \"Role\": \"\",\n  \"Handler\": \"\",\n  \"Code\": {\n    \"ZipFile\": \"\",\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ImageUri\": \"\"\n  },\n  \"Description\": \"\",\n  \"Timeout\": 0,\n  \"MemorySize\": 0,\n  \"Publish\": false,\n  \"VpcConfig\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"PackageType\": \"\",\n  \"DeadLetterConfig\": {\n    \"TargetArn\": \"\"\n  },\n  \"Environment\": {\n    \"Variables\": \"\"\n  },\n  \"KMSKeyArn\": \"\",\n  \"TracingConfig\": {\n    \"Mode\": \"\"\n  },\n  \"Tags\": {},\n  \"Layers\": [],\n  \"FileSystemConfigs\": [\n    {\n      \"Arn\": \"\",\n      \"LocalMountPath\": \"\"\n    }\n  ],\n  \"ImageConfig\": {\n    \"EntryPoint\": \"\",\n    \"Command\": \"\",\n    \"WorkingDirectory\": \"\"\n  },\n  \"CodeSigningConfigArn\": \"\",\n  \"Architectures\": [],\n  \"EphemeralStorage\": {\n    \"Size\": \"\"\n  },\n  \"SnapStart\": {\n    \"ApplyOn\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-03-31/functions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/2015-03-31/functions")
  .header("content-type", "application/json")
  .body("{\n  \"FunctionName\": \"\",\n  \"Runtime\": \"\",\n  \"Role\": \"\",\n  \"Handler\": \"\",\n  \"Code\": {\n    \"ZipFile\": \"\",\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ImageUri\": \"\"\n  },\n  \"Description\": \"\",\n  \"Timeout\": 0,\n  \"MemorySize\": 0,\n  \"Publish\": false,\n  \"VpcConfig\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"PackageType\": \"\",\n  \"DeadLetterConfig\": {\n    \"TargetArn\": \"\"\n  },\n  \"Environment\": {\n    \"Variables\": \"\"\n  },\n  \"KMSKeyArn\": \"\",\n  \"TracingConfig\": {\n    \"Mode\": \"\"\n  },\n  \"Tags\": {},\n  \"Layers\": [],\n  \"FileSystemConfigs\": [\n    {\n      \"Arn\": \"\",\n      \"LocalMountPath\": \"\"\n    }\n  ],\n  \"ImageConfig\": {\n    \"EntryPoint\": \"\",\n    \"Command\": \"\",\n    \"WorkingDirectory\": \"\"\n  },\n  \"CodeSigningConfigArn\": \"\",\n  \"Architectures\": [],\n  \"EphemeralStorage\": {\n    \"Size\": \"\"\n  },\n  \"SnapStart\": {\n    \"ApplyOn\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  FunctionName: '',
  Runtime: '',
  Role: '',
  Handler: '',
  Code: {
    ZipFile: '',
    S3Bucket: '',
    S3Key: '',
    S3ObjectVersion: '',
    ImageUri: ''
  },
  Description: '',
  Timeout: 0,
  MemorySize: 0,
  Publish: false,
  VpcConfig: {
    SubnetIds: '',
    SecurityGroupIds: ''
  },
  PackageType: '',
  DeadLetterConfig: {
    TargetArn: ''
  },
  Environment: {
    Variables: ''
  },
  KMSKeyArn: '',
  TracingConfig: {
    Mode: ''
  },
  Tags: {},
  Layers: [],
  FileSystemConfigs: [
    {
      Arn: '',
      LocalMountPath: ''
    }
  ],
  ImageConfig: {
    EntryPoint: '',
    Command: '',
    WorkingDirectory: ''
  },
  CodeSigningConfigArn: '',
  Architectures: [],
  EphemeralStorage: {
    Size: ''
  },
  SnapStart: {
    ApplyOn: ''
  }
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-03-31/functions',
  headers: {'content-type': 'application/json'},
  data: {
    FunctionName: '',
    Runtime: '',
    Role: '',
    Handler: '',
    Code: {ZipFile: '', S3Bucket: '', S3Key: '', S3ObjectVersion: '', ImageUri: ''},
    Description: '',
    Timeout: 0,
    MemorySize: 0,
    Publish: false,
    VpcConfig: {SubnetIds: '', SecurityGroupIds: ''},
    PackageType: '',
    DeadLetterConfig: {TargetArn: ''},
    Environment: {Variables: ''},
    KMSKeyArn: '',
    TracingConfig: {Mode: ''},
    Tags: {},
    Layers: [],
    FileSystemConfigs: [{Arn: '', LocalMountPath: ''}],
    ImageConfig: {EntryPoint: '', Command: '', WorkingDirectory: ''},
    CodeSigningConfigArn: '',
    Architectures: [],
    EphemeralStorage: {Size: ''},
    SnapStart: {ApplyOn: ''}
  }
};

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

const url = '{{baseUrl}}/2015-03-31/functions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"FunctionName":"","Runtime":"","Role":"","Handler":"","Code":{"ZipFile":"","S3Bucket":"","S3Key":"","S3ObjectVersion":"","ImageUri":""},"Description":"","Timeout":0,"MemorySize":0,"Publish":false,"VpcConfig":{"SubnetIds":"","SecurityGroupIds":""},"PackageType":"","DeadLetterConfig":{"TargetArn":""},"Environment":{"Variables":""},"KMSKeyArn":"","TracingConfig":{"Mode":""},"Tags":{},"Layers":[],"FileSystemConfigs":[{"Arn":"","LocalMountPath":""}],"ImageConfig":{"EntryPoint":"","Command":"","WorkingDirectory":""},"CodeSigningConfigArn":"","Architectures":[],"EphemeralStorage":{"Size":""},"SnapStart":{"ApplyOn":""}}'
};

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}}/2015-03-31/functions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "FunctionName": "",\n  "Runtime": "",\n  "Role": "",\n  "Handler": "",\n  "Code": {\n    "ZipFile": "",\n    "S3Bucket": "",\n    "S3Key": "",\n    "S3ObjectVersion": "",\n    "ImageUri": ""\n  },\n  "Description": "",\n  "Timeout": 0,\n  "MemorySize": 0,\n  "Publish": false,\n  "VpcConfig": {\n    "SubnetIds": "",\n    "SecurityGroupIds": ""\n  },\n  "PackageType": "",\n  "DeadLetterConfig": {\n    "TargetArn": ""\n  },\n  "Environment": {\n    "Variables": ""\n  },\n  "KMSKeyArn": "",\n  "TracingConfig": {\n    "Mode": ""\n  },\n  "Tags": {},\n  "Layers": [],\n  "FileSystemConfigs": [\n    {\n      "Arn": "",\n      "LocalMountPath": ""\n    }\n  ],\n  "ImageConfig": {\n    "EntryPoint": "",\n    "Command": "",\n    "WorkingDirectory": ""\n  },\n  "CodeSigningConfigArn": "",\n  "Architectures": [],\n  "EphemeralStorage": {\n    "Size": ""\n  },\n  "SnapStart": {\n    "ApplyOn": ""\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  \"FunctionName\": \"\",\n  \"Runtime\": \"\",\n  \"Role\": \"\",\n  \"Handler\": \"\",\n  \"Code\": {\n    \"ZipFile\": \"\",\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ImageUri\": \"\"\n  },\n  \"Description\": \"\",\n  \"Timeout\": 0,\n  \"MemorySize\": 0,\n  \"Publish\": false,\n  \"VpcConfig\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"PackageType\": \"\",\n  \"DeadLetterConfig\": {\n    \"TargetArn\": \"\"\n  },\n  \"Environment\": {\n    \"Variables\": \"\"\n  },\n  \"KMSKeyArn\": \"\",\n  \"TracingConfig\": {\n    \"Mode\": \"\"\n  },\n  \"Tags\": {},\n  \"Layers\": [],\n  \"FileSystemConfigs\": [\n    {\n      \"Arn\": \"\",\n      \"LocalMountPath\": \"\"\n    }\n  ],\n  \"ImageConfig\": {\n    \"EntryPoint\": \"\",\n    \"Command\": \"\",\n    \"WorkingDirectory\": \"\"\n  },\n  \"CodeSigningConfigArn\": \"\",\n  \"Architectures\": [],\n  \"EphemeralStorage\": {\n    \"Size\": \"\"\n  },\n  \"SnapStart\": {\n    \"ApplyOn\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2015-03-31/functions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-03-31/functions',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({
  FunctionName: '',
  Runtime: '',
  Role: '',
  Handler: '',
  Code: {ZipFile: '', S3Bucket: '', S3Key: '', S3ObjectVersion: '', ImageUri: ''},
  Description: '',
  Timeout: 0,
  MemorySize: 0,
  Publish: false,
  VpcConfig: {SubnetIds: '', SecurityGroupIds: ''},
  PackageType: '',
  DeadLetterConfig: {TargetArn: ''},
  Environment: {Variables: ''},
  KMSKeyArn: '',
  TracingConfig: {Mode: ''},
  Tags: {},
  Layers: [],
  FileSystemConfigs: [{Arn: '', LocalMountPath: ''}],
  ImageConfig: {EntryPoint: '', Command: '', WorkingDirectory: ''},
  CodeSigningConfigArn: '',
  Architectures: [],
  EphemeralStorage: {Size: ''},
  SnapStart: {ApplyOn: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-03-31/functions',
  headers: {'content-type': 'application/json'},
  body: {
    FunctionName: '',
    Runtime: '',
    Role: '',
    Handler: '',
    Code: {ZipFile: '', S3Bucket: '', S3Key: '', S3ObjectVersion: '', ImageUri: ''},
    Description: '',
    Timeout: 0,
    MemorySize: 0,
    Publish: false,
    VpcConfig: {SubnetIds: '', SecurityGroupIds: ''},
    PackageType: '',
    DeadLetterConfig: {TargetArn: ''},
    Environment: {Variables: ''},
    KMSKeyArn: '',
    TracingConfig: {Mode: ''},
    Tags: {},
    Layers: [],
    FileSystemConfigs: [{Arn: '', LocalMountPath: ''}],
    ImageConfig: {EntryPoint: '', Command: '', WorkingDirectory: ''},
    CodeSigningConfigArn: '',
    Architectures: [],
    EphemeralStorage: {Size: ''},
    SnapStart: {ApplyOn: ''}
  },
  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}}/2015-03-31/functions');

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

req.type('json');
req.send({
  FunctionName: '',
  Runtime: '',
  Role: '',
  Handler: '',
  Code: {
    ZipFile: '',
    S3Bucket: '',
    S3Key: '',
    S3ObjectVersion: '',
    ImageUri: ''
  },
  Description: '',
  Timeout: 0,
  MemorySize: 0,
  Publish: false,
  VpcConfig: {
    SubnetIds: '',
    SecurityGroupIds: ''
  },
  PackageType: '',
  DeadLetterConfig: {
    TargetArn: ''
  },
  Environment: {
    Variables: ''
  },
  KMSKeyArn: '',
  TracingConfig: {
    Mode: ''
  },
  Tags: {},
  Layers: [],
  FileSystemConfigs: [
    {
      Arn: '',
      LocalMountPath: ''
    }
  ],
  ImageConfig: {
    EntryPoint: '',
    Command: '',
    WorkingDirectory: ''
  },
  CodeSigningConfigArn: '',
  Architectures: [],
  EphemeralStorage: {
    Size: ''
  },
  SnapStart: {
    ApplyOn: ''
  }
});

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}}/2015-03-31/functions',
  headers: {'content-type': 'application/json'},
  data: {
    FunctionName: '',
    Runtime: '',
    Role: '',
    Handler: '',
    Code: {ZipFile: '', S3Bucket: '', S3Key: '', S3ObjectVersion: '', ImageUri: ''},
    Description: '',
    Timeout: 0,
    MemorySize: 0,
    Publish: false,
    VpcConfig: {SubnetIds: '', SecurityGroupIds: ''},
    PackageType: '',
    DeadLetterConfig: {TargetArn: ''},
    Environment: {Variables: ''},
    KMSKeyArn: '',
    TracingConfig: {Mode: ''},
    Tags: {},
    Layers: [],
    FileSystemConfigs: [{Arn: '', LocalMountPath: ''}],
    ImageConfig: {EntryPoint: '', Command: '', WorkingDirectory: ''},
    CodeSigningConfigArn: '',
    Architectures: [],
    EphemeralStorage: {Size: ''},
    SnapStart: {ApplyOn: ''}
  }
};

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

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

const url = '{{baseUrl}}/2015-03-31/functions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"FunctionName":"","Runtime":"","Role":"","Handler":"","Code":{"ZipFile":"","S3Bucket":"","S3Key":"","S3ObjectVersion":"","ImageUri":""},"Description":"","Timeout":0,"MemorySize":0,"Publish":false,"VpcConfig":{"SubnetIds":"","SecurityGroupIds":""},"PackageType":"","DeadLetterConfig":{"TargetArn":""},"Environment":{"Variables":""},"KMSKeyArn":"","TracingConfig":{"Mode":""},"Tags":{},"Layers":[],"FileSystemConfigs":[{"Arn":"","LocalMountPath":""}],"ImageConfig":{"EntryPoint":"","Command":"","WorkingDirectory":""},"CodeSigningConfigArn":"","Architectures":[],"EphemeralStorage":{"Size":""},"SnapStart":{"ApplyOn":""}}'
};

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 = @{ @"FunctionName": @"",
                              @"Runtime": @"",
                              @"Role": @"",
                              @"Handler": @"",
                              @"Code": @{ @"ZipFile": @"", @"S3Bucket": @"", @"S3Key": @"", @"S3ObjectVersion": @"", @"ImageUri": @"" },
                              @"Description": @"",
                              @"Timeout": @0,
                              @"MemorySize": @0,
                              @"Publish": @NO,
                              @"VpcConfig": @{ @"SubnetIds": @"", @"SecurityGroupIds": @"" },
                              @"PackageType": @"",
                              @"DeadLetterConfig": @{ @"TargetArn": @"" },
                              @"Environment": @{ @"Variables": @"" },
                              @"KMSKeyArn": @"",
                              @"TracingConfig": @{ @"Mode": @"" },
                              @"Tags": @{  },
                              @"Layers": @[  ],
                              @"FileSystemConfigs": @[ @{ @"Arn": @"", @"LocalMountPath": @"" } ],
                              @"ImageConfig": @{ @"EntryPoint": @"", @"Command": @"", @"WorkingDirectory": @"" },
                              @"CodeSigningConfigArn": @"",
                              @"Architectures": @[  ],
                              @"EphemeralStorage": @{ @"Size": @"" },
                              @"SnapStart": @{ @"ApplyOn": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-03-31/functions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/2015-03-31/functions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"FunctionName\": \"\",\n  \"Runtime\": \"\",\n  \"Role\": \"\",\n  \"Handler\": \"\",\n  \"Code\": {\n    \"ZipFile\": \"\",\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ImageUri\": \"\"\n  },\n  \"Description\": \"\",\n  \"Timeout\": 0,\n  \"MemorySize\": 0,\n  \"Publish\": false,\n  \"VpcConfig\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"PackageType\": \"\",\n  \"DeadLetterConfig\": {\n    \"TargetArn\": \"\"\n  },\n  \"Environment\": {\n    \"Variables\": \"\"\n  },\n  \"KMSKeyArn\": \"\",\n  \"TracingConfig\": {\n    \"Mode\": \"\"\n  },\n  \"Tags\": {},\n  \"Layers\": [],\n  \"FileSystemConfigs\": [\n    {\n      \"Arn\": \"\",\n      \"LocalMountPath\": \"\"\n    }\n  ],\n  \"ImageConfig\": {\n    \"EntryPoint\": \"\",\n    \"Command\": \"\",\n    \"WorkingDirectory\": \"\"\n  },\n  \"CodeSigningConfigArn\": \"\",\n  \"Architectures\": [],\n  \"EphemeralStorage\": {\n    \"Size\": \"\"\n  },\n  \"SnapStart\": {\n    \"ApplyOn\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/2015-03-31/functions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'FunctionName' => '',
    'Runtime' => '',
    'Role' => '',
    'Handler' => '',
    'Code' => [
        'ZipFile' => '',
        'S3Bucket' => '',
        'S3Key' => '',
        'S3ObjectVersion' => '',
        'ImageUri' => ''
    ],
    'Description' => '',
    'Timeout' => 0,
    'MemorySize' => 0,
    'Publish' => null,
    'VpcConfig' => [
        'SubnetIds' => '',
        'SecurityGroupIds' => ''
    ],
    'PackageType' => '',
    'DeadLetterConfig' => [
        'TargetArn' => ''
    ],
    'Environment' => [
        'Variables' => ''
    ],
    'KMSKeyArn' => '',
    'TracingConfig' => [
        'Mode' => ''
    ],
    'Tags' => [
        
    ],
    'Layers' => [
        
    ],
    'FileSystemConfigs' => [
        [
                'Arn' => '',
                'LocalMountPath' => ''
        ]
    ],
    'ImageConfig' => [
        'EntryPoint' => '',
        'Command' => '',
        'WorkingDirectory' => ''
    ],
    'CodeSigningConfigArn' => '',
    'Architectures' => [
        
    ],
    'EphemeralStorage' => [
        'Size' => ''
    ],
    'SnapStart' => [
        'ApplyOn' => ''
    ]
  ]),
  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}}/2015-03-31/functions', [
  'body' => '{
  "FunctionName": "",
  "Runtime": "",
  "Role": "",
  "Handler": "",
  "Code": {
    "ZipFile": "",
    "S3Bucket": "",
    "S3Key": "",
    "S3ObjectVersion": "",
    "ImageUri": ""
  },
  "Description": "",
  "Timeout": 0,
  "MemorySize": 0,
  "Publish": false,
  "VpcConfig": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  },
  "PackageType": "",
  "DeadLetterConfig": {
    "TargetArn": ""
  },
  "Environment": {
    "Variables": ""
  },
  "KMSKeyArn": "",
  "TracingConfig": {
    "Mode": ""
  },
  "Tags": {},
  "Layers": [],
  "FileSystemConfigs": [
    {
      "Arn": "",
      "LocalMountPath": ""
    }
  ],
  "ImageConfig": {
    "EntryPoint": "",
    "Command": "",
    "WorkingDirectory": ""
  },
  "CodeSigningConfigArn": "",
  "Architectures": [],
  "EphemeralStorage": {
    "Size": ""
  },
  "SnapStart": {
    "ApplyOn": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2015-03-31/functions');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'FunctionName' => '',
  'Runtime' => '',
  'Role' => '',
  'Handler' => '',
  'Code' => [
    'ZipFile' => '',
    'S3Bucket' => '',
    'S3Key' => '',
    'S3ObjectVersion' => '',
    'ImageUri' => ''
  ],
  'Description' => '',
  'Timeout' => 0,
  'MemorySize' => 0,
  'Publish' => null,
  'VpcConfig' => [
    'SubnetIds' => '',
    'SecurityGroupIds' => ''
  ],
  'PackageType' => '',
  'DeadLetterConfig' => [
    'TargetArn' => ''
  ],
  'Environment' => [
    'Variables' => ''
  ],
  'KMSKeyArn' => '',
  'TracingConfig' => [
    'Mode' => ''
  ],
  'Tags' => [
    
  ],
  'Layers' => [
    
  ],
  'FileSystemConfigs' => [
    [
        'Arn' => '',
        'LocalMountPath' => ''
    ]
  ],
  'ImageConfig' => [
    'EntryPoint' => '',
    'Command' => '',
    'WorkingDirectory' => ''
  ],
  'CodeSigningConfigArn' => '',
  'Architectures' => [
    
  ],
  'EphemeralStorage' => [
    'Size' => ''
  ],
  'SnapStart' => [
    'ApplyOn' => ''
  ]
]));

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

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

append(json_encode([
  'FunctionName' => '',
  'Runtime' => '',
  'Role' => '',
  'Handler' => '',
  'Code' => [
    'ZipFile' => '',
    'S3Bucket' => '',
    'S3Key' => '',
    'S3ObjectVersion' => '',
    'ImageUri' => ''
  ],
  'Description' => '',
  'Timeout' => 0,
  'MemorySize' => 0,
  'Publish' => null,
  'VpcConfig' => [
    'SubnetIds' => '',
    'SecurityGroupIds' => ''
  ],
  'PackageType' => '',
  'DeadLetterConfig' => [
    'TargetArn' => ''
  ],
  'Environment' => [
    'Variables' => ''
  ],
  'KMSKeyArn' => '',
  'TracingConfig' => [
    'Mode' => ''
  ],
  'Tags' => [
    
  ],
  'Layers' => [
    
  ],
  'FileSystemConfigs' => [
    [
        'Arn' => '',
        'LocalMountPath' => ''
    ]
  ],
  'ImageConfig' => [
    'EntryPoint' => '',
    'Command' => '',
    'WorkingDirectory' => ''
  ],
  'CodeSigningConfigArn' => '',
  'Architectures' => [
    
  ],
  'EphemeralStorage' => [
    'Size' => ''
  ],
  'SnapStart' => [
    'ApplyOn' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/2015-03-31/functions');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-03-31/functions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FunctionName": "",
  "Runtime": "",
  "Role": "",
  "Handler": "",
  "Code": {
    "ZipFile": "",
    "S3Bucket": "",
    "S3Key": "",
    "S3ObjectVersion": "",
    "ImageUri": ""
  },
  "Description": "",
  "Timeout": 0,
  "MemorySize": 0,
  "Publish": false,
  "VpcConfig": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  },
  "PackageType": "",
  "DeadLetterConfig": {
    "TargetArn": ""
  },
  "Environment": {
    "Variables": ""
  },
  "KMSKeyArn": "",
  "TracingConfig": {
    "Mode": ""
  },
  "Tags": {},
  "Layers": [],
  "FileSystemConfigs": [
    {
      "Arn": "",
      "LocalMountPath": ""
    }
  ],
  "ImageConfig": {
    "EntryPoint": "",
    "Command": "",
    "WorkingDirectory": ""
  },
  "CodeSigningConfigArn": "",
  "Architectures": [],
  "EphemeralStorage": {
    "Size": ""
  },
  "SnapStart": {
    "ApplyOn": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-03-31/functions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FunctionName": "",
  "Runtime": "",
  "Role": "",
  "Handler": "",
  "Code": {
    "ZipFile": "",
    "S3Bucket": "",
    "S3Key": "",
    "S3ObjectVersion": "",
    "ImageUri": ""
  },
  "Description": "",
  "Timeout": 0,
  "MemorySize": 0,
  "Publish": false,
  "VpcConfig": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  },
  "PackageType": "",
  "DeadLetterConfig": {
    "TargetArn": ""
  },
  "Environment": {
    "Variables": ""
  },
  "KMSKeyArn": "",
  "TracingConfig": {
    "Mode": ""
  },
  "Tags": {},
  "Layers": [],
  "FileSystemConfigs": [
    {
      "Arn": "",
      "LocalMountPath": ""
    }
  ],
  "ImageConfig": {
    "EntryPoint": "",
    "Command": "",
    "WorkingDirectory": ""
  },
  "CodeSigningConfigArn": "",
  "Architectures": [],
  "EphemeralStorage": {
    "Size": ""
  },
  "SnapStart": {
    "ApplyOn": ""
  }
}'

import http.client

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

payload = "{\n  \"FunctionName\": \"\",\n  \"Runtime\": \"\",\n  \"Role\": \"\",\n  \"Handler\": \"\",\n  \"Code\": {\n    \"ZipFile\": \"\",\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ImageUri\": \"\"\n  },\n  \"Description\": \"\",\n  \"Timeout\": 0,\n  \"MemorySize\": 0,\n  \"Publish\": false,\n  \"VpcConfig\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"PackageType\": \"\",\n  \"DeadLetterConfig\": {\n    \"TargetArn\": \"\"\n  },\n  \"Environment\": {\n    \"Variables\": \"\"\n  },\n  \"KMSKeyArn\": \"\",\n  \"TracingConfig\": {\n    \"Mode\": \"\"\n  },\n  \"Tags\": {},\n  \"Layers\": [],\n  \"FileSystemConfigs\": [\n    {\n      \"Arn\": \"\",\n      \"LocalMountPath\": \"\"\n    }\n  ],\n  \"ImageConfig\": {\n    \"EntryPoint\": \"\",\n    \"Command\": \"\",\n    \"WorkingDirectory\": \"\"\n  },\n  \"CodeSigningConfigArn\": \"\",\n  \"Architectures\": [],\n  \"EphemeralStorage\": {\n    \"Size\": \"\"\n  },\n  \"SnapStart\": {\n    \"ApplyOn\": \"\"\n  }\n}"

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

conn.request("POST", "/baseUrl/2015-03-31/functions", payload, headers)

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

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

import requests

url = "{{baseUrl}}/2015-03-31/functions"

payload = {
    "FunctionName": "",
    "Runtime": "",
    "Role": "",
    "Handler": "",
    "Code": {
        "ZipFile": "",
        "S3Bucket": "",
        "S3Key": "",
        "S3ObjectVersion": "",
        "ImageUri": ""
    },
    "Description": "",
    "Timeout": 0,
    "MemorySize": 0,
    "Publish": False,
    "VpcConfig": {
        "SubnetIds": "",
        "SecurityGroupIds": ""
    },
    "PackageType": "",
    "DeadLetterConfig": { "TargetArn": "" },
    "Environment": { "Variables": "" },
    "KMSKeyArn": "",
    "TracingConfig": { "Mode": "" },
    "Tags": {},
    "Layers": [],
    "FileSystemConfigs": [
        {
            "Arn": "",
            "LocalMountPath": ""
        }
    ],
    "ImageConfig": {
        "EntryPoint": "",
        "Command": "",
        "WorkingDirectory": ""
    },
    "CodeSigningConfigArn": "",
    "Architectures": [],
    "EphemeralStorage": { "Size": "" },
    "SnapStart": { "ApplyOn": "" }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-03-31/functions"

payload <- "{\n  \"FunctionName\": \"\",\n  \"Runtime\": \"\",\n  \"Role\": \"\",\n  \"Handler\": \"\",\n  \"Code\": {\n    \"ZipFile\": \"\",\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ImageUri\": \"\"\n  },\n  \"Description\": \"\",\n  \"Timeout\": 0,\n  \"MemorySize\": 0,\n  \"Publish\": false,\n  \"VpcConfig\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"PackageType\": \"\",\n  \"DeadLetterConfig\": {\n    \"TargetArn\": \"\"\n  },\n  \"Environment\": {\n    \"Variables\": \"\"\n  },\n  \"KMSKeyArn\": \"\",\n  \"TracingConfig\": {\n    \"Mode\": \"\"\n  },\n  \"Tags\": {},\n  \"Layers\": [],\n  \"FileSystemConfigs\": [\n    {\n      \"Arn\": \"\",\n      \"LocalMountPath\": \"\"\n    }\n  ],\n  \"ImageConfig\": {\n    \"EntryPoint\": \"\",\n    \"Command\": \"\",\n    \"WorkingDirectory\": \"\"\n  },\n  \"CodeSigningConfigArn\": \"\",\n  \"Architectures\": [],\n  \"EphemeralStorage\": {\n    \"Size\": \"\"\n  },\n  \"SnapStart\": {\n    \"ApplyOn\": \"\"\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}}/2015-03-31/functions")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"FunctionName\": \"\",\n  \"Runtime\": \"\",\n  \"Role\": \"\",\n  \"Handler\": \"\",\n  \"Code\": {\n    \"ZipFile\": \"\",\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ImageUri\": \"\"\n  },\n  \"Description\": \"\",\n  \"Timeout\": 0,\n  \"MemorySize\": 0,\n  \"Publish\": false,\n  \"VpcConfig\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"PackageType\": \"\",\n  \"DeadLetterConfig\": {\n    \"TargetArn\": \"\"\n  },\n  \"Environment\": {\n    \"Variables\": \"\"\n  },\n  \"KMSKeyArn\": \"\",\n  \"TracingConfig\": {\n    \"Mode\": \"\"\n  },\n  \"Tags\": {},\n  \"Layers\": [],\n  \"FileSystemConfigs\": [\n    {\n      \"Arn\": \"\",\n      \"LocalMountPath\": \"\"\n    }\n  ],\n  \"ImageConfig\": {\n    \"EntryPoint\": \"\",\n    \"Command\": \"\",\n    \"WorkingDirectory\": \"\"\n  },\n  \"CodeSigningConfigArn\": \"\",\n  \"Architectures\": [],\n  \"EphemeralStorage\": {\n    \"Size\": \"\"\n  },\n  \"SnapStart\": {\n    \"ApplyOn\": \"\"\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/2015-03-31/functions') do |req|
  req.body = "{\n  \"FunctionName\": \"\",\n  \"Runtime\": \"\",\n  \"Role\": \"\",\n  \"Handler\": \"\",\n  \"Code\": {\n    \"ZipFile\": \"\",\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ImageUri\": \"\"\n  },\n  \"Description\": \"\",\n  \"Timeout\": 0,\n  \"MemorySize\": 0,\n  \"Publish\": false,\n  \"VpcConfig\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"PackageType\": \"\",\n  \"DeadLetterConfig\": {\n    \"TargetArn\": \"\"\n  },\n  \"Environment\": {\n    \"Variables\": \"\"\n  },\n  \"KMSKeyArn\": \"\",\n  \"TracingConfig\": {\n    \"Mode\": \"\"\n  },\n  \"Tags\": {},\n  \"Layers\": [],\n  \"FileSystemConfigs\": [\n    {\n      \"Arn\": \"\",\n      \"LocalMountPath\": \"\"\n    }\n  ],\n  \"ImageConfig\": {\n    \"EntryPoint\": \"\",\n    \"Command\": \"\",\n    \"WorkingDirectory\": \"\"\n  },\n  \"CodeSigningConfigArn\": \"\",\n  \"Architectures\": [],\n  \"EphemeralStorage\": {\n    \"Size\": \"\"\n  },\n  \"SnapStart\": {\n    \"ApplyOn\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-03-31/functions";

    let payload = json!({
        "FunctionName": "",
        "Runtime": "",
        "Role": "",
        "Handler": "",
        "Code": json!({
            "ZipFile": "",
            "S3Bucket": "",
            "S3Key": "",
            "S3ObjectVersion": "",
            "ImageUri": ""
        }),
        "Description": "",
        "Timeout": 0,
        "MemorySize": 0,
        "Publish": false,
        "VpcConfig": json!({
            "SubnetIds": "",
            "SecurityGroupIds": ""
        }),
        "PackageType": "",
        "DeadLetterConfig": json!({"TargetArn": ""}),
        "Environment": json!({"Variables": ""}),
        "KMSKeyArn": "",
        "TracingConfig": json!({"Mode": ""}),
        "Tags": json!({}),
        "Layers": (),
        "FileSystemConfigs": (
            json!({
                "Arn": "",
                "LocalMountPath": ""
            })
        ),
        "ImageConfig": json!({
            "EntryPoint": "",
            "Command": "",
            "WorkingDirectory": ""
        }),
        "CodeSigningConfigArn": "",
        "Architectures": (),
        "EphemeralStorage": json!({"Size": ""}),
        "SnapStart": json!({"ApplyOn": ""})
    });

    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 '{
  "FunctionName": "",
  "Runtime": "",
  "Role": "",
  "Handler": "",
  "Code": {
    "ZipFile": "",
    "S3Bucket": "",
    "S3Key": "",
    "S3ObjectVersion": "",
    "ImageUri": ""
  },
  "Description": "",
  "Timeout": 0,
  "MemorySize": 0,
  "Publish": false,
  "VpcConfig": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  },
  "PackageType": "",
  "DeadLetterConfig": {
    "TargetArn": ""
  },
  "Environment": {
    "Variables": ""
  },
  "KMSKeyArn": "",
  "TracingConfig": {
    "Mode": ""
  },
  "Tags": {},
  "Layers": [],
  "FileSystemConfigs": [
    {
      "Arn": "",
      "LocalMountPath": ""
    }
  ],
  "ImageConfig": {
    "EntryPoint": "",
    "Command": "",
    "WorkingDirectory": ""
  },
  "CodeSigningConfigArn": "",
  "Architectures": [],
  "EphemeralStorage": {
    "Size": ""
  },
  "SnapStart": {
    "ApplyOn": ""
  }
}' |  \
  http POST {{baseUrl}}/2015-03-31/functions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "FunctionName": "",\n  "Runtime": "",\n  "Role": "",\n  "Handler": "",\n  "Code": {\n    "ZipFile": "",\n    "S3Bucket": "",\n    "S3Key": "",\n    "S3ObjectVersion": "",\n    "ImageUri": ""\n  },\n  "Description": "",\n  "Timeout": 0,\n  "MemorySize": 0,\n  "Publish": false,\n  "VpcConfig": {\n    "SubnetIds": "",\n    "SecurityGroupIds": ""\n  },\n  "PackageType": "",\n  "DeadLetterConfig": {\n    "TargetArn": ""\n  },\n  "Environment": {\n    "Variables": ""\n  },\n  "KMSKeyArn": "",\n  "TracingConfig": {\n    "Mode": ""\n  },\n  "Tags": {},\n  "Layers": [],\n  "FileSystemConfigs": [\n    {\n      "Arn": "",\n      "LocalMountPath": ""\n    }\n  ],\n  "ImageConfig": {\n    "EntryPoint": "",\n    "Command": "",\n    "WorkingDirectory": ""\n  },\n  "CodeSigningConfigArn": "",\n  "Architectures": [],\n  "EphemeralStorage": {\n    "Size": ""\n  },\n  "SnapStart": {\n    "ApplyOn": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/2015-03-31/functions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "FunctionName": "",
  "Runtime": "",
  "Role": "",
  "Handler": "",
  "Code": [
    "ZipFile": "",
    "S3Bucket": "",
    "S3Key": "",
    "S3ObjectVersion": "",
    "ImageUri": ""
  ],
  "Description": "",
  "Timeout": 0,
  "MemorySize": 0,
  "Publish": false,
  "VpcConfig": [
    "SubnetIds": "",
    "SecurityGroupIds": ""
  ],
  "PackageType": "",
  "DeadLetterConfig": ["TargetArn": ""],
  "Environment": ["Variables": ""],
  "KMSKeyArn": "",
  "TracingConfig": ["Mode": ""],
  "Tags": [],
  "Layers": [],
  "FileSystemConfigs": [
    [
      "Arn": "",
      "LocalMountPath": ""
    ]
  ],
  "ImageConfig": [
    "EntryPoint": "",
    "Command": "",
    "WorkingDirectory": ""
  ],
  "CodeSigningConfigArn": "",
  "Architectures": [],
  "EphemeralStorage": ["Size": ""],
  "SnapStart": ["ApplyOn": ""]
] as [String : Any]

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

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

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2021-10-31/functions/:FunctionName/url");

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  \"AuthType\": \"\",\n  \"Cors\": {\n    \"AllowCredentials\": \"\",\n    \"AllowHeaders\": \"\",\n    \"AllowMethods\": \"\",\n    \"AllowOrigins\": \"\",\n    \"ExposeHeaders\": \"\",\n    \"MaxAge\": \"\"\n  },\n  \"InvokeMode\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/2021-10-31/functions/:FunctionName/url" {:content-type :json
                                                                                   :form-params {:AuthType ""
                                                                                                 :Cors {:AllowCredentials ""
                                                                                                        :AllowHeaders ""
                                                                                                        :AllowMethods ""
                                                                                                        :AllowOrigins ""
                                                                                                        :ExposeHeaders ""
                                                                                                        :MaxAge ""}
                                                                                                 :InvokeMode ""}})

require "http/client"

url = "{{baseUrl}}/2021-10-31/functions/:FunctionName/url"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"AuthType\": \"\",\n  \"Cors\": {\n    \"AllowCredentials\": \"\",\n    \"AllowHeaders\": \"\",\n    \"AllowMethods\": \"\",\n    \"AllowOrigins\": \"\",\n    \"ExposeHeaders\": \"\",\n    \"MaxAge\": \"\"\n  },\n  \"InvokeMode\": \"\"\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}}/2021-10-31/functions/:FunctionName/url"),
    Content = new StringContent("{\n  \"AuthType\": \"\",\n  \"Cors\": {\n    \"AllowCredentials\": \"\",\n    \"AllowHeaders\": \"\",\n    \"AllowMethods\": \"\",\n    \"AllowOrigins\": \"\",\n    \"ExposeHeaders\": \"\",\n    \"MaxAge\": \"\"\n  },\n  \"InvokeMode\": \"\"\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}}/2021-10-31/functions/:FunctionName/url");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AuthType\": \"\",\n  \"Cors\": {\n    \"AllowCredentials\": \"\",\n    \"AllowHeaders\": \"\",\n    \"AllowMethods\": \"\",\n    \"AllowOrigins\": \"\",\n    \"ExposeHeaders\": \"\",\n    \"MaxAge\": \"\"\n  },\n  \"InvokeMode\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2021-10-31/functions/:FunctionName/url"

	payload := strings.NewReader("{\n  \"AuthType\": \"\",\n  \"Cors\": {\n    \"AllowCredentials\": \"\",\n    \"AllowHeaders\": \"\",\n    \"AllowMethods\": \"\",\n    \"AllowOrigins\": \"\",\n    \"ExposeHeaders\": \"\",\n    \"MaxAge\": \"\"\n  },\n  \"InvokeMode\": \"\"\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/2021-10-31/functions/:FunctionName/url HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 199

{
  "AuthType": "",
  "Cors": {
    "AllowCredentials": "",
    "AllowHeaders": "",
    "AllowMethods": "",
    "AllowOrigins": "",
    "ExposeHeaders": "",
    "MaxAge": ""
  },
  "InvokeMode": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2021-10-31/functions/:FunctionName/url")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AuthType\": \"\",\n  \"Cors\": {\n    \"AllowCredentials\": \"\",\n    \"AllowHeaders\": \"\",\n    \"AllowMethods\": \"\",\n    \"AllowOrigins\": \"\",\n    \"ExposeHeaders\": \"\",\n    \"MaxAge\": \"\"\n  },\n  \"InvokeMode\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2021-10-31/functions/:FunctionName/url"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AuthType\": \"\",\n  \"Cors\": {\n    \"AllowCredentials\": \"\",\n    \"AllowHeaders\": \"\",\n    \"AllowMethods\": \"\",\n    \"AllowOrigins\": \"\",\n    \"ExposeHeaders\": \"\",\n    \"MaxAge\": \"\"\n  },\n  \"InvokeMode\": \"\"\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  \"AuthType\": \"\",\n  \"Cors\": {\n    \"AllowCredentials\": \"\",\n    \"AllowHeaders\": \"\",\n    \"AllowMethods\": \"\",\n    \"AllowOrigins\": \"\",\n    \"ExposeHeaders\": \"\",\n    \"MaxAge\": \"\"\n  },\n  \"InvokeMode\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2021-10-31/functions/:FunctionName/url")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/2021-10-31/functions/:FunctionName/url")
  .header("content-type", "application/json")
  .body("{\n  \"AuthType\": \"\",\n  \"Cors\": {\n    \"AllowCredentials\": \"\",\n    \"AllowHeaders\": \"\",\n    \"AllowMethods\": \"\",\n    \"AllowOrigins\": \"\",\n    \"ExposeHeaders\": \"\",\n    \"MaxAge\": \"\"\n  },\n  \"InvokeMode\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AuthType: '',
  Cors: {
    AllowCredentials: '',
    AllowHeaders: '',
    AllowMethods: '',
    AllowOrigins: '',
    ExposeHeaders: '',
    MaxAge: ''
  },
  InvokeMode: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/2021-10-31/functions/:FunctionName/url');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2021-10-31/functions/:FunctionName/url',
  headers: {'content-type': 'application/json'},
  data: {
    AuthType: '',
    Cors: {
      AllowCredentials: '',
      AllowHeaders: '',
      AllowMethods: '',
      AllowOrigins: '',
      ExposeHeaders: '',
      MaxAge: ''
    },
    InvokeMode: ''
  }
};

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

const url = '{{baseUrl}}/2021-10-31/functions/:FunctionName/url';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"AuthType":"","Cors":{"AllowCredentials":"","AllowHeaders":"","AllowMethods":"","AllowOrigins":"","ExposeHeaders":"","MaxAge":""},"InvokeMode":""}'
};

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}}/2021-10-31/functions/:FunctionName/url',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AuthType": "",\n  "Cors": {\n    "AllowCredentials": "",\n    "AllowHeaders": "",\n    "AllowMethods": "",\n    "AllowOrigins": "",\n    "ExposeHeaders": "",\n    "MaxAge": ""\n  },\n  "InvokeMode": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AuthType\": \"\",\n  \"Cors\": {\n    \"AllowCredentials\": \"\",\n    \"AllowHeaders\": \"\",\n    \"AllowMethods\": \"\",\n    \"AllowOrigins\": \"\",\n    \"ExposeHeaders\": \"\",\n    \"MaxAge\": \"\"\n  },\n  \"InvokeMode\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2021-10-31/functions/:FunctionName/url")
  .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/2021-10-31/functions/:FunctionName/url',
  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({
  AuthType: '',
  Cors: {
    AllowCredentials: '',
    AllowHeaders: '',
    AllowMethods: '',
    AllowOrigins: '',
    ExposeHeaders: '',
    MaxAge: ''
  },
  InvokeMode: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2021-10-31/functions/:FunctionName/url',
  headers: {'content-type': 'application/json'},
  body: {
    AuthType: '',
    Cors: {
      AllowCredentials: '',
      AllowHeaders: '',
      AllowMethods: '',
      AllowOrigins: '',
      ExposeHeaders: '',
      MaxAge: ''
    },
    InvokeMode: ''
  },
  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}}/2021-10-31/functions/:FunctionName/url');

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

req.type('json');
req.send({
  AuthType: '',
  Cors: {
    AllowCredentials: '',
    AllowHeaders: '',
    AllowMethods: '',
    AllowOrigins: '',
    ExposeHeaders: '',
    MaxAge: ''
  },
  InvokeMode: ''
});

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}}/2021-10-31/functions/:FunctionName/url',
  headers: {'content-type': 'application/json'},
  data: {
    AuthType: '',
    Cors: {
      AllowCredentials: '',
      AllowHeaders: '',
      AllowMethods: '',
      AllowOrigins: '',
      ExposeHeaders: '',
      MaxAge: ''
    },
    InvokeMode: ''
  }
};

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

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

const url = '{{baseUrl}}/2021-10-31/functions/:FunctionName/url';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"AuthType":"","Cors":{"AllowCredentials":"","AllowHeaders":"","AllowMethods":"","AllowOrigins":"","ExposeHeaders":"","MaxAge":""},"InvokeMode":""}'
};

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 = @{ @"AuthType": @"",
                              @"Cors": @{ @"AllowCredentials": @"", @"AllowHeaders": @"", @"AllowMethods": @"", @"AllowOrigins": @"", @"ExposeHeaders": @"", @"MaxAge": @"" },
                              @"InvokeMode": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2021-10-31/functions/:FunctionName/url"]
                                                       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}}/2021-10-31/functions/:FunctionName/url" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"AuthType\": \"\",\n  \"Cors\": {\n    \"AllowCredentials\": \"\",\n    \"AllowHeaders\": \"\",\n    \"AllowMethods\": \"\",\n    \"AllowOrigins\": \"\",\n    \"ExposeHeaders\": \"\",\n    \"MaxAge\": \"\"\n  },\n  \"InvokeMode\": \"\"\n}" in

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

 "{{baseUrl}}/2021-10-31/functions/:FunctionName/url",
  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([
    'AuthType' => '',
    'Cors' => [
        'AllowCredentials' => '',
        'AllowHeaders' => '',
        'AllowMethods' => '',
        'AllowOrigins' => '',
        'ExposeHeaders' => '',
        'MaxAge' => ''
    ],
    'InvokeMode' => ''
  ]),
  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}}/2021-10-31/functions/:FunctionName/url', [
  'body' => '{
  "AuthType": "",
  "Cors": {
    "AllowCredentials": "",
    "AllowHeaders": "",
    "AllowMethods": "",
    "AllowOrigins": "",
    "ExposeHeaders": "",
    "MaxAge": ""
  },
  "InvokeMode": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2021-10-31/functions/:FunctionName/url');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AuthType' => '',
  'Cors' => [
    'AllowCredentials' => '',
    'AllowHeaders' => '',
    'AllowMethods' => '',
    'AllowOrigins' => '',
    'ExposeHeaders' => '',
    'MaxAge' => ''
  ],
  'InvokeMode' => ''
]));

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

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

append(json_encode([
  'AuthType' => '',
  'Cors' => [
    'AllowCredentials' => '',
    'AllowHeaders' => '',
    'AllowMethods' => '',
    'AllowOrigins' => '',
    'ExposeHeaders' => '',
    'MaxAge' => ''
  ],
  'InvokeMode' => ''
]));
$request->setRequestUrl('{{baseUrl}}/2021-10-31/functions/:FunctionName/url');
$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}}/2021-10-31/functions/:FunctionName/url' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AuthType": "",
  "Cors": {
    "AllowCredentials": "",
    "AllowHeaders": "",
    "AllowMethods": "",
    "AllowOrigins": "",
    "ExposeHeaders": "",
    "MaxAge": ""
  },
  "InvokeMode": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2021-10-31/functions/:FunctionName/url' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AuthType": "",
  "Cors": {
    "AllowCredentials": "",
    "AllowHeaders": "",
    "AllowMethods": "",
    "AllowOrigins": "",
    "ExposeHeaders": "",
    "MaxAge": ""
  },
  "InvokeMode": ""
}'

import http.client

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

payload = "{\n  \"AuthType\": \"\",\n  \"Cors\": {\n    \"AllowCredentials\": \"\",\n    \"AllowHeaders\": \"\",\n    \"AllowMethods\": \"\",\n    \"AllowOrigins\": \"\",\n    \"ExposeHeaders\": \"\",\n    \"MaxAge\": \"\"\n  },\n  \"InvokeMode\": \"\"\n}"

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

conn.request("POST", "/baseUrl/2021-10-31/functions/:FunctionName/url", payload, headers)

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

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

import requests

url = "{{baseUrl}}/2021-10-31/functions/:FunctionName/url"

payload = {
    "AuthType": "",
    "Cors": {
        "AllowCredentials": "",
        "AllowHeaders": "",
        "AllowMethods": "",
        "AllowOrigins": "",
        "ExposeHeaders": "",
        "MaxAge": ""
    },
    "InvokeMode": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/2021-10-31/functions/:FunctionName/url"

payload <- "{\n  \"AuthType\": \"\",\n  \"Cors\": {\n    \"AllowCredentials\": \"\",\n    \"AllowHeaders\": \"\",\n    \"AllowMethods\": \"\",\n    \"AllowOrigins\": \"\",\n    \"ExposeHeaders\": \"\",\n    \"MaxAge\": \"\"\n  },\n  \"InvokeMode\": \"\"\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}}/2021-10-31/functions/:FunctionName/url")

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  \"AuthType\": \"\",\n  \"Cors\": {\n    \"AllowCredentials\": \"\",\n    \"AllowHeaders\": \"\",\n    \"AllowMethods\": \"\",\n    \"AllowOrigins\": \"\",\n    \"ExposeHeaders\": \"\",\n    \"MaxAge\": \"\"\n  },\n  \"InvokeMode\": \"\"\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/2021-10-31/functions/:FunctionName/url') do |req|
  req.body = "{\n  \"AuthType\": \"\",\n  \"Cors\": {\n    \"AllowCredentials\": \"\",\n    \"AllowHeaders\": \"\",\n    \"AllowMethods\": \"\",\n    \"AllowOrigins\": \"\",\n    \"ExposeHeaders\": \"\",\n    \"MaxAge\": \"\"\n  },\n  \"InvokeMode\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2021-10-31/functions/:FunctionName/url";

    let payload = json!({
        "AuthType": "",
        "Cors": json!({
            "AllowCredentials": "",
            "AllowHeaders": "",
            "AllowMethods": "",
            "AllowOrigins": "",
            "ExposeHeaders": "",
            "MaxAge": ""
        }),
        "InvokeMode": ""
    });

    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 '{
  "AuthType": "",
  "Cors": {
    "AllowCredentials": "",
    "AllowHeaders": "",
    "AllowMethods": "",
    "AllowOrigins": "",
    "ExposeHeaders": "",
    "MaxAge": ""
  },
  "InvokeMode": ""
}' |  \
  http POST {{baseUrl}}/2021-10-31/functions/:FunctionName/url \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "AuthType": "",\n  "Cors": {\n    "AllowCredentials": "",\n    "AllowHeaders": "",\n    "AllowMethods": "",\n    "AllowOrigins": "",\n    "ExposeHeaders": "",\n    "MaxAge": ""\n  },\n  "InvokeMode": ""\n}' \
  --output-document \
  - {{baseUrl}}/2021-10-31/functions/:FunctionName/url

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "AuthType": "",
  "Cors": [
    "AllowCredentials": "",
    "AllowHeaders": "",
    "AllowMethods": "",
    "AllowOrigins": "",
    "ExposeHeaders": "",
    "MaxAge": ""
  ],
  "InvokeMode": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2021-10-31/functions/:FunctionName/url")! 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}}/2015-03-31/functions/:FunctionName/aliases/:Name");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases/:Name")

require "http/client"

url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/aliases/:Name");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-03-31/functions/:FunctionName/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/2015-03-31/functions/:FunctionName/aliases/:Name HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases/:Name")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/aliases/:Name")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/aliases/:Name');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases/:Name'
};

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

const url = '{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/aliases/:Name',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-03-31/functions/:FunctionName/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/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/aliases/:Name" in

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

 "{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/aliases/:Name');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases/:Name');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases/:Name');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases/:Name' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases/:Name' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/2015-03-31/functions/:FunctionName/aliases/:Name")

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

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

import requests

url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases/:Name"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases/:Name"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-03-31/functions/:FunctionName/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/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/aliases/:Name

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/2015-03-31/functions/:FunctionName/aliases/:Name

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn")

require "http/client"

url = "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn"

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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn"

	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/2020-04-22/code-signing-configs/:CodeSigningConfigArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn"))
    .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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn")
  .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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn'
};

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

const url = '{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn';
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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2020-04-22/code-signing-configs/:CodeSigningConfigArn',
  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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn');

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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn'
};

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

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

const url = '{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn';
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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn"]
                                                       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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn" in

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

 "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn",
  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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn');

echo $response->getBody();

setUrl('{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/2020-04-22/code-signing-configs/:CodeSigningConfigArn")

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

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

import requests

url = "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn")

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/2020-04-22/code-signing-configs/:CodeSigningConfigArn') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn";

    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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn")! 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}}/2015-03-31/event-source-mappings/:UUID");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/2015-03-31/event-source-mappings/:UUID")

require "http/client"

url = "{{baseUrl}}/2015-03-31/event-source-mappings/:UUID"

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}}/2015-03-31/event-source-mappings/:UUID"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2015-03-31/event-source-mappings/:UUID");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-03-31/event-source-mappings/:UUID"

	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/2015-03-31/event-source-mappings/:UUID HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/2015-03-31/event-source-mappings/:UUID")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-03-31/event-source-mappings/:UUID"))
    .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}}/2015-03-31/event-source-mappings/:UUID")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/2015-03-31/event-source-mappings/:UUID")
  .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}}/2015-03-31/event-source-mappings/:UUID');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/2015-03-31/event-source-mappings/:UUID'
};

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

const url = '{{baseUrl}}/2015-03-31/event-source-mappings/:UUID';
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}}/2015-03-31/event-source-mappings/:UUID',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-03-31/event-source-mappings/:UUID")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-03-31/event-source-mappings/:UUID',
  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}}/2015-03-31/event-source-mappings/:UUID'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/2015-03-31/event-source-mappings/:UUID');

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}}/2015-03-31/event-source-mappings/:UUID'
};

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

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

const url = '{{baseUrl}}/2015-03-31/event-source-mappings/:UUID';
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}}/2015-03-31/event-source-mappings/:UUID"]
                                                       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}}/2015-03-31/event-source-mappings/:UUID" in

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

 "{{baseUrl}}/2015-03-31/event-source-mappings/:UUID",
  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}}/2015-03-31/event-source-mappings/:UUID');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-03-31/event-source-mappings/:UUID');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/2015-03-31/event-source-mappings/:UUID');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-03-31/event-source-mappings/:UUID' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-03-31/event-source-mappings/:UUID' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/2015-03-31/event-source-mappings/:UUID")

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

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

import requests

url = "{{baseUrl}}/2015-03-31/event-source-mappings/:UUID"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-03-31/event-source-mappings/:UUID"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-03-31/event-source-mappings/:UUID")

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/2015-03-31/event-source-mappings/:UUID') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-03-31/event-source-mappings/:UUID";

    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}}/2015-03-31/event-source-mappings/:UUID

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/2015-03-31/event-source-mappings/:UUID

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-03-31/event-source-mappings/:UUID")! 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}}/2015-03-31/functions/:FunctionName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/2015-03-31/functions/:FunctionName")

require "http/client"

url = "{{baseUrl}}/2015-03-31/functions/:FunctionName"

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

var client = new RestClient("{{baseUrl}}/2015-03-31/functions/:FunctionName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-03-31/functions/:FunctionName"

	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/2015-03-31/functions/:FunctionName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/2015-03-31/functions/:FunctionName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-03-31/functions/:FunctionName"))
    .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}}/2015-03-31/functions/:FunctionName")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/2015-03-31/functions/:FunctionName")
  .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}}/2015-03-31/functions/:FunctionName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/2015-03-31/functions/:FunctionName'
};

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

const url = '{{baseUrl}}/2015-03-31/functions/:FunctionName';
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}}/2015-03-31/functions/:FunctionName',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-03-31/functions/:FunctionName")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-03-31/functions/:FunctionName',
  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}}/2015-03-31/functions/:FunctionName'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/2015-03-31/functions/:FunctionName');

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}}/2015-03-31/functions/:FunctionName'
};

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

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

const url = '{{baseUrl}}/2015-03-31/functions/:FunctionName';
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}}/2015-03-31/functions/:FunctionName"]
                                                       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}}/2015-03-31/functions/:FunctionName" in

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

 "{{baseUrl}}/2015-03-31/functions/:FunctionName",
  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}}/2015-03-31/functions/:FunctionName');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-03-31/functions/:FunctionName');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/2015-03-31/functions/:FunctionName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-03-31/functions/:FunctionName' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-03-31/functions/:FunctionName' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/2015-03-31/functions/:FunctionName")

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

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

import requests

url = "{{baseUrl}}/2015-03-31/functions/:FunctionName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-03-31/functions/:FunctionName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-03-31/functions/:FunctionName")

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/2015-03-31/functions/:FunctionName') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-03-31/functions/:FunctionName";

    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}}/2015-03-31/functions/:FunctionName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/2015-03-31/functions/:FunctionName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-03-31/functions/:FunctionName")! 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}}/2020-06-30/functions/:FunctionName/code-signing-config");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config")

require "http/client"

url = "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config"

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}}/2020-06-30/functions/:FunctionName/code-signing-config"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config"

	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/2020-06-30/functions/:FunctionName/code-signing-config HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config"))
    .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}}/2020-06-30/functions/:FunctionName/code-signing-config")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config")
  .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}}/2020-06-30/functions/:FunctionName/code-signing-config');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config'
};

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

const url = '{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config';
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}}/2020-06-30/functions/:FunctionName/code-signing-config',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2020-06-30/functions/:FunctionName/code-signing-config',
  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}}/2020-06-30/functions/:FunctionName/code-signing-config'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config');

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}}/2020-06-30/functions/:FunctionName/code-signing-config'
};

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

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

const url = '{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config';
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}}/2020-06-30/functions/:FunctionName/code-signing-config"]
                                                       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}}/2020-06-30/functions/:FunctionName/code-signing-config" in

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

 "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config",
  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}}/2020-06-30/functions/:FunctionName/code-signing-config');

echo $response->getBody();

setUrl('{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/2020-06-30/functions/:FunctionName/code-signing-config")

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

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

import requests

url = "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config")

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/2020-06-30/functions/:FunctionName/code-signing-config') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config";

    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}}/2020-06-30/functions/:FunctionName/code-signing-config

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config")! 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}}/2017-10-31/functions/:FunctionName/concurrency");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency")

require "http/client"

url = "{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency"

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

var client = new RestClient("{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency"

	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/2017-10-31/functions/:FunctionName/concurrency HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency"))
    .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}}/2017-10-31/functions/:FunctionName/concurrency")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency")
  .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}}/2017-10-31/functions/:FunctionName/concurrency');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency'
};

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

const url = '{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency';
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}}/2017-10-31/functions/:FunctionName/concurrency',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2017-10-31/functions/:FunctionName/concurrency',
  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}}/2017-10-31/functions/:FunctionName/concurrency'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency');

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}}/2017-10-31/functions/:FunctionName/concurrency'
};

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

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

const url = '{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency';
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}}/2017-10-31/functions/:FunctionName/concurrency"]
                                                       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}}/2017-10-31/functions/:FunctionName/concurrency" in

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

 "{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency",
  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}}/2017-10-31/functions/:FunctionName/concurrency');

echo $response->getBody();

setUrl('{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/2017-10-31/functions/:FunctionName/concurrency")

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

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

import requests

url = "{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency")

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/2017-10-31/functions/:FunctionName/concurrency') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency";

    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}}/2017-10-31/functions/:FunctionName/concurrency

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency")! 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}}/2019-09-25/functions/:FunctionName/event-invoke-config");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config")

require "http/client"

url = "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config"

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}}/2019-09-25/functions/:FunctionName/event-invoke-config"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config"

	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/2019-09-25/functions/:FunctionName/event-invoke-config HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config"))
    .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}}/2019-09-25/functions/:FunctionName/event-invoke-config")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config")
  .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}}/2019-09-25/functions/:FunctionName/event-invoke-config');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config'
};

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

const url = '{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config';
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}}/2019-09-25/functions/:FunctionName/event-invoke-config',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2019-09-25/functions/:FunctionName/event-invoke-config',
  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}}/2019-09-25/functions/:FunctionName/event-invoke-config'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config');

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}}/2019-09-25/functions/:FunctionName/event-invoke-config'
};

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

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

const url = '{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config';
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}}/2019-09-25/functions/:FunctionName/event-invoke-config"]
                                                       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}}/2019-09-25/functions/:FunctionName/event-invoke-config" in

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

 "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config",
  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}}/2019-09-25/functions/:FunctionName/event-invoke-config');

echo $response->getBody();

setUrl('{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/2019-09-25/functions/:FunctionName/event-invoke-config")

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

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

import requests

url = "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config")

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/2019-09-25/functions/:FunctionName/event-invoke-config') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config";

    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}}/2019-09-25/functions/:FunctionName/event-invoke-config

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config")! 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}}/2021-10-31/functions/:FunctionName/url");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/2021-10-31/functions/:FunctionName/url")

require "http/client"

url = "{{baseUrl}}/2021-10-31/functions/:FunctionName/url"

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

var client = new RestClient("{{baseUrl}}/2021-10-31/functions/:FunctionName/url");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2021-10-31/functions/:FunctionName/url"

	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/2021-10-31/functions/:FunctionName/url HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/2021-10-31/functions/:FunctionName/url")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2021-10-31/functions/:FunctionName/url"))
    .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}}/2021-10-31/functions/:FunctionName/url")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/2021-10-31/functions/:FunctionName/url")
  .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}}/2021-10-31/functions/:FunctionName/url');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/2021-10-31/functions/:FunctionName/url'
};

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

const url = '{{baseUrl}}/2021-10-31/functions/:FunctionName/url';
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}}/2021-10-31/functions/:FunctionName/url',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2021-10-31/functions/:FunctionName/url")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2021-10-31/functions/:FunctionName/url',
  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}}/2021-10-31/functions/:FunctionName/url'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/2021-10-31/functions/:FunctionName/url');

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}}/2021-10-31/functions/:FunctionName/url'
};

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

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

const url = '{{baseUrl}}/2021-10-31/functions/:FunctionName/url';
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}}/2021-10-31/functions/:FunctionName/url"]
                                                       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}}/2021-10-31/functions/:FunctionName/url" in

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

 "{{baseUrl}}/2021-10-31/functions/:FunctionName/url",
  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}}/2021-10-31/functions/:FunctionName/url');

echo $response->getBody();

setUrl('{{baseUrl}}/2021-10-31/functions/:FunctionName/url');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/2021-10-31/functions/:FunctionName/url');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2021-10-31/functions/:FunctionName/url' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2021-10-31/functions/:FunctionName/url' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/2021-10-31/functions/:FunctionName/url")

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

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

import requests

url = "{{baseUrl}}/2021-10-31/functions/:FunctionName/url"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2021-10-31/functions/:FunctionName/url"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2021-10-31/functions/:FunctionName/url")

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/2021-10-31/functions/:FunctionName/url') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2021-10-31/functions/:FunctionName/url";

    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}}/2021-10-31/functions/:FunctionName/url

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/2021-10-31/functions/:FunctionName/url

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2021-10-31/functions/:FunctionName/url")! 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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber")

require "http/client"

url = "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber"

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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber"

	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/2018-10-31/layers/:LayerName/versions/:VersionNumber HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber"))
    .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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber")
  .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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber'
};

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

const url = '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber';
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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2018-10-31/layers/:LayerName/versions/:VersionNumber',
  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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber');

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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber'
};

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

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

const url = '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber';
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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber"]
                                                       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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber" in

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

 "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber",
  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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber');

echo $response->getBody();

setUrl('{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/2018-10-31/layers/:LayerName/versions/:VersionNumber")

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

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

import requests

url = "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber")

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/2018-10-31/layers/:LayerName/versions/:VersionNumber') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber";

    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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber")! 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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier" {:query-params {:Qualifier ""}})

require "http/client"

url = "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier"

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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier"

	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/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier"))
    .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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier")
  .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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier',
  params: {Qualifier: ''}
};

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

const url = '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier';
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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=',
  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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier',
  qs: {Qualifier: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier');

req.query({
  Qualifier: ''
});

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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier',
  params: {Qualifier: ''}
};

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

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

const url = '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier';
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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier"]
                                                       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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier" in

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

 "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier",
  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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier');

echo $response->getBody();

setUrl('{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier');
$request->setMethod(HTTP_METH_DELETE);

$request->setQueryData([
  'Qualifier' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier');
$request->setRequestMethod('DELETE');
$request->setQuery(new http\QueryString([
  'Qualifier' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier' -Method DELETE 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier' -Method DELETE 

import http.client

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

conn.request("DELETE", "/baseUrl/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=")

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

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

import requests

url = "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier"

querystring = {"Qualifier":""}

response = requests.delete(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier"

queryString <- list(Qualifier = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier")

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/2019-09-30/functions/:FunctionName/provisioned-concurrency') do |req|
  req.params['Qualifier'] = ''
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier";

    let querystring = [
        ("Qualifier", ""),
    ];

    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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier'

wget --quiet \
  --method DELETE \
  --output-document \
  - '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier")! 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}}/2016-08-19/account-settings/");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2016-08-19/account-settings/")

require "http/client"

url = "{{baseUrl}}/2016-08-19/account-settings/"

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}}/2016-08-19/account-settings/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2016-08-19/account-settings/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2016-08-19/account-settings/"

	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/2016-08-19/account-settings/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2016-08-19/account-settings/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2016-08-19/account-settings/"))
    .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}}/2016-08-19/account-settings/")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2016-08-19/account-settings/")
  .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}}/2016-08-19/account-settings/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/2016-08-19/account-settings/'};

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

const url = '{{baseUrl}}/2016-08-19/account-settings/';
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}}/2016-08-19/account-settings/',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2016-08-19/account-settings/")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/2016-08-19/account-settings/');

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}}/2016-08-19/account-settings/'};

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

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

const url = '{{baseUrl}}/2016-08-19/account-settings/';
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}}/2016-08-19/account-settings/"]
                                                       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}}/2016-08-19/account-settings/" in

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

 "{{baseUrl}}/2016-08-19/account-settings/",
  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}}/2016-08-19/account-settings/');

echo $response->getBody();

setUrl('{{baseUrl}}/2016-08-19/account-settings/');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/2016-08-19/account-settings/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2016-08-19/account-settings/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2016-08-19/account-settings/' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/2016-08-19/account-settings/")

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

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

import requests

url = "{{baseUrl}}/2016-08-19/account-settings/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2016-08-19/account-settings/"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2016-08-19/account-settings/")

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/2016-08-19/account-settings/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2016-08-19/account-settings/";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/2016-08-19/account-settings/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2016-08-19/account-settings/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2016-08-19/account-settings/")! 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}}/2015-03-31/functions/:FunctionName/aliases/:Name");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases/:Name")

require "http/client"

url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/aliases/:Name");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-03-31/functions/:FunctionName/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/2015-03-31/functions/:FunctionName/aliases/:Name HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases/:Name")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/aliases/:Name")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/aliases/:Name');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases/:Name'
};

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

const url = '{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/aliases/:Name',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-03-31/functions/:FunctionName/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/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/aliases/:Name" in

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

 "{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/aliases/:Name');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases/:Name');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases/:Name');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases/:Name' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases/:Name' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/2015-03-31/functions/:FunctionName/aliases/:Name")

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

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

import requests

url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases/:Name"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases/:Name"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-03-31/functions/:FunctionName/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/2015-03-31/functions/:FunctionName/aliases/:Name') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/aliases/:Name

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-03-31/functions/:FunctionName/aliases/:Name

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn")

require "http/client"

url = "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn"

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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn"

	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/2020-04-22/code-signing-configs/:CodeSigningConfigArn HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn"))
    .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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn")
  .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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn'
};

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

const url = '{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn';
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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2020-04-22/code-signing-configs/:CodeSigningConfigArn',
  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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn');

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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn'
};

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

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

const url = '{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn';
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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn"]
                                                       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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn" in

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

 "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn",
  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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn');

echo $response->getBody();

setUrl('{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/2020-04-22/code-signing-configs/:CodeSigningConfigArn")

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

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

import requests

url = "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn")

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/2020-04-22/code-signing-configs/:CodeSigningConfigArn') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn")! 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}}/2015-03-31/event-source-mappings/:UUID");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2015-03-31/event-source-mappings/:UUID")

require "http/client"

url = "{{baseUrl}}/2015-03-31/event-source-mappings/:UUID"

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}}/2015-03-31/event-source-mappings/:UUID"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2015-03-31/event-source-mappings/:UUID");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-03-31/event-source-mappings/:UUID"

	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/2015-03-31/event-source-mappings/:UUID HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-03-31/event-source-mappings/:UUID")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-03-31/event-source-mappings/:UUID"))
    .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}}/2015-03-31/event-source-mappings/:UUID")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2015-03-31/event-source-mappings/:UUID")
  .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}}/2015-03-31/event-source-mappings/:UUID');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-03-31/event-source-mappings/:UUID'
};

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

const url = '{{baseUrl}}/2015-03-31/event-source-mappings/:UUID';
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}}/2015-03-31/event-source-mappings/:UUID',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-03-31/event-source-mappings/:UUID")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-03-31/event-source-mappings/:UUID',
  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}}/2015-03-31/event-source-mappings/:UUID'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/2015-03-31/event-source-mappings/:UUID');

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}}/2015-03-31/event-source-mappings/:UUID'
};

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

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

const url = '{{baseUrl}}/2015-03-31/event-source-mappings/:UUID';
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}}/2015-03-31/event-source-mappings/:UUID"]
                                                       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}}/2015-03-31/event-source-mappings/:UUID" in

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

 "{{baseUrl}}/2015-03-31/event-source-mappings/:UUID",
  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}}/2015-03-31/event-source-mappings/:UUID');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-03-31/event-source-mappings/:UUID');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/2015-03-31/event-source-mappings/:UUID');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-03-31/event-source-mappings/:UUID' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-03-31/event-source-mappings/:UUID' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/2015-03-31/event-source-mappings/:UUID")

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

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

import requests

url = "{{baseUrl}}/2015-03-31/event-source-mappings/:UUID"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-03-31/event-source-mappings/:UUID"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-03-31/event-source-mappings/:UUID")

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/2015-03-31/event-source-mappings/:UUID') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-03-31/event-source-mappings/:UUID";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/2015-03-31/event-source-mappings/:UUID

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-03-31/event-source-mappings/:UUID

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-03-31/event-source-mappings/:UUID")! 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}}/2015-03-31/functions/:FunctionName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2015-03-31/functions/:FunctionName")

require "http/client"

url = "{{baseUrl}}/2015-03-31/functions/:FunctionName"

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

var client = new RestClient("{{baseUrl}}/2015-03-31/functions/:FunctionName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-03-31/functions/:FunctionName"

	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/2015-03-31/functions/:FunctionName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-03-31/functions/:FunctionName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-03-31/functions/:FunctionName"))
    .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}}/2015-03-31/functions/:FunctionName")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2015-03-31/functions/:FunctionName")
  .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}}/2015-03-31/functions/:FunctionName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-03-31/functions/:FunctionName'
};

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

const url = '{{baseUrl}}/2015-03-31/functions/:FunctionName';
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}}/2015-03-31/functions/:FunctionName',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-03-31/functions/:FunctionName")
  .get()
  .build()

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

const http = require('https');

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

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/2015-03-31/functions/:FunctionName');

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}}/2015-03-31/functions/:FunctionName'
};

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

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

const url = '{{baseUrl}}/2015-03-31/functions/:FunctionName';
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}}/2015-03-31/functions/:FunctionName"]
                                                       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}}/2015-03-31/functions/:FunctionName" in

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

 "{{baseUrl}}/2015-03-31/functions/:FunctionName",
  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}}/2015-03-31/functions/:FunctionName');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-03-31/functions/:FunctionName');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/2015-03-31/functions/:FunctionName');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-03-31/functions/:FunctionName' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-03-31/functions/:FunctionName' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/2015-03-31/functions/:FunctionName")

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

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

import requests

url = "{{baseUrl}}/2015-03-31/functions/:FunctionName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-03-31/functions/:FunctionName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-03-31/functions/:FunctionName")

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/2015-03-31/functions/:FunctionName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-03-31/functions/:FunctionName";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/2015-03-31/functions/:FunctionName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-03-31/functions/:FunctionName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-03-31/functions/:FunctionName")! 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}}/2020-06-30/functions/:FunctionName/code-signing-config");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config")

require "http/client"

url = "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config"

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}}/2020-06-30/functions/:FunctionName/code-signing-config"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config"

	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/2020-06-30/functions/:FunctionName/code-signing-config HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config"))
    .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}}/2020-06-30/functions/:FunctionName/code-signing-config")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config")
  .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}}/2020-06-30/functions/:FunctionName/code-signing-config');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config'
};

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

const url = '{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config';
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}}/2020-06-30/functions/:FunctionName/code-signing-config',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2020-06-30/functions/:FunctionName/code-signing-config',
  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}}/2020-06-30/functions/:FunctionName/code-signing-config'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config');

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}}/2020-06-30/functions/:FunctionName/code-signing-config'
};

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

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

const url = '{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config';
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}}/2020-06-30/functions/:FunctionName/code-signing-config"]
                                                       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}}/2020-06-30/functions/:FunctionName/code-signing-config" in

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

 "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config",
  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}}/2020-06-30/functions/:FunctionName/code-signing-config');

echo $response->getBody();

setUrl('{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/2020-06-30/functions/:FunctionName/code-signing-config")

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

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

import requests

url = "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config")

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/2020-06-30/functions/:FunctionName/code-signing-config') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config")! 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}}/2019-09-30/functions/:FunctionName/concurrency");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2019-09-30/functions/:FunctionName/concurrency")

require "http/client"

url = "{{baseUrl}}/2019-09-30/functions/:FunctionName/concurrency"

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

var client = new RestClient("{{baseUrl}}/2019-09-30/functions/:FunctionName/concurrency");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2019-09-30/functions/:FunctionName/concurrency"

	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/2019-09-30/functions/:FunctionName/concurrency HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2019-09-30/functions/:FunctionName/concurrency")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2019-09-30/functions/:FunctionName/concurrency"))
    .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}}/2019-09-30/functions/:FunctionName/concurrency")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2019-09-30/functions/:FunctionName/concurrency")
  .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}}/2019-09-30/functions/:FunctionName/concurrency');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2019-09-30/functions/:FunctionName/concurrency'
};

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

const url = '{{baseUrl}}/2019-09-30/functions/:FunctionName/concurrency';
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}}/2019-09-30/functions/:FunctionName/concurrency',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2019-09-30/functions/:FunctionName/concurrency")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2019-09-30/functions/:FunctionName/concurrency',
  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}}/2019-09-30/functions/:FunctionName/concurrency'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/2019-09-30/functions/:FunctionName/concurrency');

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}}/2019-09-30/functions/:FunctionName/concurrency'
};

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

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

const url = '{{baseUrl}}/2019-09-30/functions/:FunctionName/concurrency';
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}}/2019-09-30/functions/:FunctionName/concurrency"]
                                                       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}}/2019-09-30/functions/:FunctionName/concurrency" in

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

 "{{baseUrl}}/2019-09-30/functions/:FunctionName/concurrency",
  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}}/2019-09-30/functions/:FunctionName/concurrency');

echo $response->getBody();

setUrl('{{baseUrl}}/2019-09-30/functions/:FunctionName/concurrency');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/2019-09-30/functions/:FunctionName/concurrency');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2019-09-30/functions/:FunctionName/concurrency' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2019-09-30/functions/:FunctionName/concurrency' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/2019-09-30/functions/:FunctionName/concurrency")

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

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

import requests

url = "{{baseUrl}}/2019-09-30/functions/:FunctionName/concurrency"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2019-09-30/functions/:FunctionName/concurrency"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2019-09-30/functions/:FunctionName/concurrency")

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/2019-09-30/functions/:FunctionName/concurrency') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2019-09-30/functions/:FunctionName/concurrency";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/2019-09-30/functions/:FunctionName/concurrency

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2019-09-30/functions/:FunctionName/concurrency

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2019-09-30/functions/:FunctionName/concurrency")! 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}}/2015-03-31/functions/:FunctionName/configuration");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2015-03-31/functions/:FunctionName/configuration")

require "http/client"

url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/configuration"

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

var client = new RestClient("{{baseUrl}}/2015-03-31/functions/:FunctionName/configuration");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-03-31/functions/:FunctionName/configuration"

	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/2015-03-31/functions/:FunctionName/configuration HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-03-31/functions/:FunctionName/configuration")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-03-31/functions/:FunctionName/configuration"))
    .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}}/2015-03-31/functions/:FunctionName/configuration")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2015-03-31/functions/:FunctionName/configuration")
  .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}}/2015-03-31/functions/:FunctionName/configuration');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-03-31/functions/:FunctionName/configuration'
};

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

const url = '{{baseUrl}}/2015-03-31/functions/:FunctionName/configuration';
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}}/2015-03-31/functions/:FunctionName/configuration',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-03-31/functions/:FunctionName/configuration")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-03-31/functions/:FunctionName/configuration',
  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}}/2015-03-31/functions/:FunctionName/configuration'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/2015-03-31/functions/:FunctionName/configuration');

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}}/2015-03-31/functions/:FunctionName/configuration'
};

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

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

const url = '{{baseUrl}}/2015-03-31/functions/:FunctionName/configuration';
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}}/2015-03-31/functions/:FunctionName/configuration"]
                                                       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}}/2015-03-31/functions/:FunctionName/configuration" in

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

 "{{baseUrl}}/2015-03-31/functions/:FunctionName/configuration",
  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}}/2015-03-31/functions/:FunctionName/configuration');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-03-31/functions/:FunctionName/configuration');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/2015-03-31/functions/:FunctionName/configuration');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-03-31/functions/:FunctionName/configuration' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-03-31/functions/:FunctionName/configuration' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/2015-03-31/functions/:FunctionName/configuration")

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

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

import requests

url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/configuration"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-03-31/functions/:FunctionName/configuration"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-03-31/functions/:FunctionName/configuration")

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/2015-03-31/functions/:FunctionName/configuration') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/configuration";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/2015-03-31/functions/:FunctionName/configuration

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-03-31/functions/:FunctionName/configuration

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-03-31/functions/:FunctionName/configuration")! 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}}/2019-09-25/functions/:FunctionName/event-invoke-config");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config")

require "http/client"

url = "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config"

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}}/2019-09-25/functions/:FunctionName/event-invoke-config"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config"

	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/2019-09-25/functions/:FunctionName/event-invoke-config HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config"))
    .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}}/2019-09-25/functions/:FunctionName/event-invoke-config")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config")
  .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}}/2019-09-25/functions/:FunctionName/event-invoke-config');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config'
};

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

const url = '{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config';
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}}/2019-09-25/functions/:FunctionName/event-invoke-config',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2019-09-25/functions/:FunctionName/event-invoke-config',
  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}}/2019-09-25/functions/:FunctionName/event-invoke-config'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config');

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}}/2019-09-25/functions/:FunctionName/event-invoke-config'
};

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

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

const url = '{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config';
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}}/2019-09-25/functions/:FunctionName/event-invoke-config"]
                                                       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}}/2019-09-25/functions/:FunctionName/event-invoke-config" in

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

 "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config",
  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}}/2019-09-25/functions/:FunctionName/event-invoke-config');

echo $response->getBody();

setUrl('{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/2019-09-25/functions/:FunctionName/event-invoke-config")

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

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

import requests

url = "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config")

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/2019-09-25/functions/:FunctionName/event-invoke-config') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config")! 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}}/2021-10-31/functions/:FunctionName/url");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2021-10-31/functions/:FunctionName/url")

require "http/client"

url = "{{baseUrl}}/2021-10-31/functions/:FunctionName/url"

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

var client = new RestClient("{{baseUrl}}/2021-10-31/functions/:FunctionName/url");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2021-10-31/functions/:FunctionName/url"

	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/2021-10-31/functions/:FunctionName/url HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2021-10-31/functions/:FunctionName/url")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2021-10-31/functions/:FunctionName/url"))
    .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}}/2021-10-31/functions/:FunctionName/url")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2021-10-31/functions/:FunctionName/url")
  .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}}/2021-10-31/functions/:FunctionName/url');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2021-10-31/functions/:FunctionName/url'
};

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

const url = '{{baseUrl}}/2021-10-31/functions/:FunctionName/url';
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}}/2021-10-31/functions/:FunctionName/url',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2021-10-31/functions/:FunctionName/url")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2021-10-31/functions/:FunctionName/url',
  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}}/2021-10-31/functions/:FunctionName/url'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/2021-10-31/functions/:FunctionName/url');

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}}/2021-10-31/functions/:FunctionName/url'
};

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

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

const url = '{{baseUrl}}/2021-10-31/functions/:FunctionName/url';
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}}/2021-10-31/functions/:FunctionName/url"]
                                                       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}}/2021-10-31/functions/:FunctionName/url" in

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

 "{{baseUrl}}/2021-10-31/functions/:FunctionName/url",
  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}}/2021-10-31/functions/:FunctionName/url');

echo $response->getBody();

setUrl('{{baseUrl}}/2021-10-31/functions/:FunctionName/url');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/2021-10-31/functions/:FunctionName/url');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2021-10-31/functions/:FunctionName/url' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2021-10-31/functions/:FunctionName/url' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/2021-10-31/functions/:FunctionName/url")

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

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

import requests

url = "{{baseUrl}}/2021-10-31/functions/:FunctionName/url"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2021-10-31/functions/:FunctionName/url"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2021-10-31/functions/:FunctionName/url")

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/2021-10-31/functions/:FunctionName/url') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2021-10-31/functions/:FunctionName/url";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/2021-10-31/functions/:FunctionName/url

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2021-10-31/functions/:FunctionName/url

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2021-10-31/functions/:FunctionName/url")! 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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber")

require "http/client"

url = "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber"

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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber"

	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/2018-10-31/layers/:LayerName/versions/:VersionNumber HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber"))
    .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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber")
  .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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber'
};

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

const url = '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber';
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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2018-10-31/layers/:LayerName/versions/:VersionNumber',
  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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber');

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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber'
};

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

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

const url = '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber';
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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber"]
                                                       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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber" in

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

 "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber",
  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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber');

echo $response->getBody();

setUrl('{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/2018-10-31/layers/:LayerName/versions/:VersionNumber")

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

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

import requests

url = "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber")

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/2018-10-31/layers/:LayerName/versions/:VersionNumber') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber")! 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}}/2018-10-31/layers?Arn=&find=#find=LayerVersion&Arn");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2018-10-31/layers#find=LayerVersion&Arn" {:query-params {:Arn ""
                                                                                                  :find ""}})

require "http/client"

url = "{{baseUrl}}/2018-10-31/layers?Arn=&find=#find=LayerVersion&Arn"

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}}/2018-10-31/layers?Arn=&find=#find=LayerVersion&Arn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2018-10-31/layers?Arn=&find=#find=LayerVersion&Arn");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2018-10-31/layers?Arn=&find=#find=LayerVersion&Arn"

	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/2018-10-31/layers?Arn=&find= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2018-10-31/layers?Arn=&find=#find=LayerVersion&Arn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2018-10-31/layers?Arn=&find=#find=LayerVersion&Arn"))
    .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}}/2018-10-31/layers?Arn=&find=#find=LayerVersion&Arn")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2018-10-31/layers?Arn=&find=#find=LayerVersion&Arn")
  .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}}/2018-10-31/layers?Arn=&find=#find=LayerVersion&Arn');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2018-10-31/layers#find=LayerVersion&Arn',
  params: {Arn: '', find: ''}
};

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

const url = '{{baseUrl}}/2018-10-31/layers?Arn=&find=#find=LayerVersion&Arn';
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}}/2018-10-31/layers?Arn=&find=#find=LayerVersion&Arn',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2018-10-31/layers?Arn=&find=#find=LayerVersion&Arn")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2018-10-31/layers?Arn=&find=',
  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}}/2018-10-31/layers#find=LayerVersion&Arn',
  qs: {Arn: '', find: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/2018-10-31/layers#find=LayerVersion&Arn');

req.query({
  Arn: '',
  find: ''
});

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}}/2018-10-31/layers#find=LayerVersion&Arn',
  params: {Arn: '', find: ''}
};

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

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

const url = '{{baseUrl}}/2018-10-31/layers?Arn=&find=#find=LayerVersion&Arn';
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}}/2018-10-31/layers?Arn=&find=#find=LayerVersion&Arn"]
                                                       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}}/2018-10-31/layers?Arn=&find=#find=LayerVersion&Arn" in

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

 "{{baseUrl}}/2018-10-31/layers?Arn=&find=#find=LayerVersion&Arn",
  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}}/2018-10-31/layers?Arn=&find=#find=LayerVersion&Arn');

echo $response->getBody();

setUrl('{{baseUrl}}/2018-10-31/layers#find=LayerVersion&Arn');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Arn' => '',
  'find' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/2018-10-31/layers#find=LayerVersion&Arn');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Arn' => '',
  'find' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2018-10-31/layers?Arn=&find=#find=LayerVersion&Arn' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2018-10-31/layers?Arn=&find=#find=LayerVersion&Arn' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/2018-10-31/layers?Arn=&find=")

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

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

import requests

url = "{{baseUrl}}/2018-10-31/layers#find=LayerVersion&Arn"

querystring = {"Arn":"","find":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2018-10-31/layers#find=LayerVersion&Arn"

queryString <- list(
  Arn = "",
  find = ""
)

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2018-10-31/layers?Arn=&find=#find=LayerVersion&Arn")

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/2018-10-31/layers') do |req|
  req.params['Arn'] = ''
  req.params['find'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2018-10-31/layers#find=LayerVersion&Arn";

    let querystring = [
        ("Arn", ""),
        ("find", ""),
    ];

    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}}/2018-10-31/layers?Arn=&find=#find=LayerVersion&Arn'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/2018-10-31/layers?Arn=&find=#find=LayerVersion&Arn'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2018-10-31/layers?Arn=&find=#find=LayerVersion&Arn")! 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}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy")

require "http/client"

url = "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy"

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

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

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

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

}

GET /baseUrl/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy'
};

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

const url = '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy'
};

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

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

const url = '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy" in

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

 "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy');

echo $response->getBody();

setUrl('{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy")

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

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

import requests

url = "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2018-10-31/layers/:LayerName/versions/:VersionNumber/policy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-03-31/functions/:FunctionName/policy");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2015-03-31/functions/:FunctionName/policy")

require "http/client"

url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/policy"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/2015-03-31/functions/:FunctionName/policy"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2015-03-31/functions/:FunctionName/policy");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-03-31/functions/:FunctionName/policy"

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

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

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

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

}

GET /baseUrl/2015-03-31/functions/:FunctionName/policy HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-03-31/functions/:FunctionName/policy")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-03-31/functions/:FunctionName/policy"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-03-31/functions/:FunctionName/policy")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2015-03-31/functions/:FunctionName/policy")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/2015-03-31/functions/:FunctionName/policy');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-03-31/functions/:FunctionName/policy'
};

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

const url = '{{baseUrl}}/2015-03-31/functions/:FunctionName/policy';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/2015-03-31/functions/:FunctionName/policy',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-03-31/functions/:FunctionName/policy")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-03-31/functions/:FunctionName/policy',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-03-31/functions/:FunctionName/policy'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/2015-03-31/functions/:FunctionName/policy');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-03-31/functions/:FunctionName/policy'
};

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

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

const url = '{{baseUrl}}/2015-03-31/functions/:FunctionName/policy';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-03-31/functions/:FunctionName/policy"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/2015-03-31/functions/:FunctionName/policy" in

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

 "{{baseUrl}}/2015-03-31/functions/:FunctionName/policy",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

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

curl_close($curl);

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

request('GET', '{{baseUrl}}/2015-03-31/functions/:FunctionName/policy');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-03-31/functions/:FunctionName/policy');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/2015-03-31/functions/:FunctionName/policy');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-03-31/functions/:FunctionName/policy' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-03-31/functions/:FunctionName/policy' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/2015-03-31/functions/:FunctionName/policy")

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

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

import requests

url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/policy"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-03-31/functions/:FunctionName/policy"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-03-31/functions/:FunctionName/policy")

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

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

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

require 'faraday'

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

response = conn.get('/baseUrl/2015-03-31/functions/:FunctionName/policy') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/policy";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/2015-03-31/functions/:FunctionName/policy

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-03-31/functions/:FunctionName/policy

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-03-31/functions/:FunctionName/policy")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier" {:query-params {:Qualifier ""}})

require "http/client"

url = "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier"

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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier"

	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/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier"))
    .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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier")
  .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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier',
  params: {Qualifier: ''}
};

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

const url = '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier';
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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=',
  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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier',
  qs: {Qualifier: ''}
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier');

req.query({
  Qualifier: ''
});

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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier',
  params: {Qualifier: ''}
};

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

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

const url = '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier';
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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier"]
                                                       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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier" in

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

 "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier",
  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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier');

echo $response->getBody();

setUrl('{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'Qualifier' => ''
]);

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

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

setRequestUrl('{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'Qualifier' => ''
]));

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

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=")

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

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

import requests

url = "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier"

querystring = {"Qualifier":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier"

queryString <- list(Qualifier = "")

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier")

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/2019-09-30/functions/:FunctionName/provisioned-concurrency') do |req|
  req.params['Qualifier'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier";

    let querystring = [
        ("Qualifier", ""),
    ];

    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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier")! 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}}/2021-07-20/functions/:FunctionName/runtime-management-config");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2021-07-20/functions/:FunctionName/runtime-management-config")

require "http/client"

url = "{{baseUrl}}/2021-07-20/functions/:FunctionName/runtime-management-config"

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}}/2021-07-20/functions/:FunctionName/runtime-management-config"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2021-07-20/functions/:FunctionName/runtime-management-config");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2021-07-20/functions/:FunctionName/runtime-management-config"

	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/2021-07-20/functions/:FunctionName/runtime-management-config HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2021-07-20/functions/:FunctionName/runtime-management-config")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2021-07-20/functions/:FunctionName/runtime-management-config"))
    .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}}/2021-07-20/functions/:FunctionName/runtime-management-config")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2021-07-20/functions/:FunctionName/runtime-management-config")
  .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}}/2021-07-20/functions/:FunctionName/runtime-management-config');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2021-07-20/functions/:FunctionName/runtime-management-config'
};

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

const url = '{{baseUrl}}/2021-07-20/functions/:FunctionName/runtime-management-config';
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}}/2021-07-20/functions/:FunctionName/runtime-management-config',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2021-07-20/functions/:FunctionName/runtime-management-config")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2021-07-20/functions/:FunctionName/runtime-management-config',
  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}}/2021-07-20/functions/:FunctionName/runtime-management-config'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/2021-07-20/functions/:FunctionName/runtime-management-config');

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}}/2021-07-20/functions/:FunctionName/runtime-management-config'
};

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

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

const url = '{{baseUrl}}/2021-07-20/functions/:FunctionName/runtime-management-config';
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}}/2021-07-20/functions/:FunctionName/runtime-management-config"]
                                                       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}}/2021-07-20/functions/:FunctionName/runtime-management-config" in

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

 "{{baseUrl}}/2021-07-20/functions/:FunctionName/runtime-management-config",
  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}}/2021-07-20/functions/:FunctionName/runtime-management-config');

echo $response->getBody();

setUrl('{{baseUrl}}/2021-07-20/functions/:FunctionName/runtime-management-config');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/2021-07-20/functions/:FunctionName/runtime-management-config');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2021-07-20/functions/:FunctionName/runtime-management-config' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2021-07-20/functions/:FunctionName/runtime-management-config' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/2021-07-20/functions/:FunctionName/runtime-management-config")

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

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

import requests

url = "{{baseUrl}}/2021-07-20/functions/:FunctionName/runtime-management-config"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2021-07-20/functions/:FunctionName/runtime-management-config"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2021-07-20/functions/:FunctionName/runtime-management-config")

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/2021-07-20/functions/:FunctionName/runtime-management-config') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2021-07-20/functions/:FunctionName/runtime-management-config";

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

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

    dbg!(results);
}

http GET {{baseUrl}}/2021-07-20/functions/:FunctionName/runtime-management-config

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2021-07-20/functions/:FunctionName/runtime-management-config

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2021-07-20/functions/:FunctionName/runtime-management-config")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-03-31/functions/:FunctionName/invocations");

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}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/2015-03-31/functions/:FunctionName/invocations" {:content-type :json
                                                                                           :form-params {:Payload ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/2015-03-31/functions/:FunctionName/invocations"

	payload := strings.NewReader("{\n  \"Payload\": \"\"\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/2015-03-31/functions/:FunctionName/invocations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 19

{
  "Payload": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-03-31/functions/:FunctionName/invocations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Payload\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/2015-03-31/functions/:FunctionName/invocations")
  .header("content-type", "application/json")
  .body("{\n  \"Payload\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/2015-03-31/functions/:FunctionName/invocations');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-03-31/functions/:FunctionName/invocations',
  headers: {'content-type': 'application/json'},
  data: {Payload: ''}
};

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

const url = '{{baseUrl}}/2015-03-31/functions/:FunctionName/invocations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Payload":""}'
};

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}}/2015-03-31/functions/:FunctionName/invocations',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Payload": ""\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}")
val request = Request.Builder()
  .url("{{baseUrl}}/2015-03-31/functions/:FunctionName/invocations")
  .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/2015-03-31/functions/:FunctionName/invocations',
  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: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-03-31/functions/:FunctionName/invocations',
  headers: {'content-type': 'application/json'},
  body: {Payload: ''},
  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}}/2015-03-31/functions/:FunctionName/invocations');

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

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

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}}/2015-03-31/functions/:FunctionName/invocations',
  headers: {'content-type': 'application/json'},
  data: {Payload: ''}
};

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

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

const url = '{{baseUrl}}/2015-03-31/functions/:FunctionName/invocations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Payload":""}'
};

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-03-31/functions/:FunctionName/invocations"]
                                                       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}}/2015-03-31/functions/:FunctionName/invocations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Payload\": \"\"\n}" in

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

 "{{baseUrl}}/2015-03-31/functions/:FunctionName/invocations",
  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' => ''
  ]),
  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}}/2015-03-31/functions/:FunctionName/invocations', [
  'body' => '{
  "Payload": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2015-03-31/functions/:FunctionName/invocations');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'Payload' => ''
]));
$request->setRequestUrl('{{baseUrl}}/2015-03-31/functions/:FunctionName/invocations');
$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}}/2015-03-31/functions/:FunctionName/invocations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Payload": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-03-31/functions/:FunctionName/invocations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Payload": ""
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/2015-03-31/functions/:FunctionName/invocations", payload, headers)

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

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

import requests

url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/invocations"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-03-31/functions/:FunctionName/invocations"

payload <- "{\n  \"Payload\": \"\"\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}}/2015-03-31/functions/:FunctionName/invocations")

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}"

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/2015-03-31/functions/:FunctionName/invocations') do |req|
  req.body = "{\n  \"Payload\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/invocations";

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

    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": ""
}' |  \
  http POST {{baseUrl}}/2015-03-31/functions/:FunctionName/invocations \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Payload": ""\n}' \
  --output-document \
  - {{baseUrl}}/2015-03-31/functions/:FunctionName/invocations

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-03-31/functions/:FunctionName/invocations")! 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}}/2014-11-13/functions/:FunctionName/invoke-async/");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/2014-11-13/functions/:FunctionName/invoke-async/" {:content-type :json
                                                                                             :form-params {:InvokeArgs ""}})

require "http/client"

url = "{{baseUrl}}/2014-11-13/functions/:FunctionName/invoke-async/"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"InvokeArgs\": \"\"\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}}/2014-11-13/functions/:FunctionName/invoke-async/"),
    Content = new StringContent("{\n  \"InvokeArgs\": \"\"\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}}/2014-11-13/functions/:FunctionName/invoke-async/");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"InvokeArgs\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2014-11-13/functions/:FunctionName/invoke-async/"

	payload := strings.NewReader("{\n  \"InvokeArgs\": \"\"\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/2014-11-13/functions/:FunctionName/invoke-async/ HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "InvokeArgs": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2014-11-13/functions/:FunctionName/invoke-async/")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"InvokeArgs\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2014-11-13/functions/:FunctionName/invoke-async/"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"InvokeArgs\": \"\"\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  \"InvokeArgs\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2014-11-13/functions/:FunctionName/invoke-async/")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/2014-11-13/functions/:FunctionName/invoke-async/")
  .header("content-type", "application/json")
  .body("{\n  \"InvokeArgs\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/2014-11-13/functions/:FunctionName/invoke-async/');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2014-11-13/functions/:FunctionName/invoke-async/',
  headers: {'content-type': 'application/json'},
  data: {InvokeArgs: ''}
};

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

const url = '{{baseUrl}}/2014-11-13/functions/:FunctionName/invoke-async/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"InvokeArgs":""}'
};

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}}/2014-11-13/functions/:FunctionName/invoke-async/',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "InvokeArgs": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"InvokeArgs\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2014-11-13/functions/:FunctionName/invoke-async/")
  .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/2014-11-13/functions/:FunctionName/invoke-async/',
  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({InvokeArgs: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2014-11-13/functions/:FunctionName/invoke-async/',
  headers: {'content-type': 'application/json'},
  body: {InvokeArgs: ''},
  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}}/2014-11-13/functions/:FunctionName/invoke-async/');

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

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

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}}/2014-11-13/functions/:FunctionName/invoke-async/',
  headers: {'content-type': 'application/json'},
  data: {InvokeArgs: ''}
};

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

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

const url = '{{baseUrl}}/2014-11-13/functions/:FunctionName/invoke-async/';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"InvokeArgs":""}'
};

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2014-11-13/functions/:FunctionName/invoke-async/"]
                                                       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}}/2014-11-13/functions/:FunctionName/invoke-async/" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"InvokeArgs\": \"\"\n}" in

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

 "{{baseUrl}}/2014-11-13/functions/:FunctionName/invoke-async/",
  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([
    'InvokeArgs' => ''
  ]),
  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}}/2014-11-13/functions/:FunctionName/invoke-async/', [
  'body' => '{
  "InvokeArgs": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2014-11-13/functions/:FunctionName/invoke-async/');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'InvokeArgs' => ''
]));
$request->setRequestUrl('{{baseUrl}}/2014-11-13/functions/:FunctionName/invoke-async/');
$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}}/2014-11-13/functions/:FunctionName/invoke-async/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InvokeArgs": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2014-11-13/functions/:FunctionName/invoke-async/' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InvokeArgs": ""
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/2014-11-13/functions/:FunctionName/invoke-async/", payload, headers)

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

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

import requests

url = "{{baseUrl}}/2014-11-13/functions/:FunctionName/invoke-async/"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/2014-11-13/functions/:FunctionName/invoke-async/"

payload <- "{\n  \"InvokeArgs\": \"\"\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}}/2014-11-13/functions/:FunctionName/invoke-async/")

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  \"InvokeArgs\": \"\"\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/2014-11-13/functions/:FunctionName/invoke-async/') do |req|
  req.body = "{\n  \"InvokeArgs\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2014-11-13/functions/:FunctionName/invoke-async/";

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

    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 '{
  "InvokeArgs": ""
}' |  \
  http POST {{baseUrl}}/2014-11-13/functions/:FunctionName/invoke-async/ \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "InvokeArgs": ""\n}' \
  --output-document \
  - {{baseUrl}}/2014-11-13/functions/:FunctionName/invoke-async/

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2014-11-13/functions/:FunctionName/invoke-async/")! 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}}/2021-11-15/functions/:FunctionName/response-streaming-invocations");

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}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/2021-11-15/functions/:FunctionName/response-streaming-invocations" {:content-type :json
                                                                                                              :form-params {:Payload ""}})

require "http/client"

url = "{{baseUrl}}/2021-11-15/functions/:FunctionName/response-streaming-invocations"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Payload\": \"\"\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}}/2021-11-15/functions/:FunctionName/response-streaming-invocations"),
    Content = new StringContent("{\n  \"Payload\": \"\"\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}}/2021-11-15/functions/:FunctionName/response-streaming-invocations");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Payload\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2021-11-15/functions/:FunctionName/response-streaming-invocations"

	payload := strings.NewReader("{\n  \"Payload\": \"\"\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/2021-11-15/functions/:FunctionName/response-streaming-invocations HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 19

{
  "Payload": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2021-11-15/functions/:FunctionName/response-streaming-invocations")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Payload\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2021-11-15/functions/:FunctionName/response-streaming-invocations"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Payload\": \"\"\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}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2021-11-15/functions/:FunctionName/response-streaming-invocations")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/2021-11-15/functions/:FunctionName/response-streaming-invocations")
  .header("content-type", "application/json")
  .body("{\n  \"Payload\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/2021-11-15/functions/:FunctionName/response-streaming-invocations');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2021-11-15/functions/:FunctionName/response-streaming-invocations',
  headers: {'content-type': 'application/json'},
  data: {Payload: ''}
};

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

const url = '{{baseUrl}}/2021-11-15/functions/:FunctionName/response-streaming-invocations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Payload":""}'
};

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}}/2021-11-15/functions/:FunctionName/response-streaming-invocations',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Payload": ""\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}")
val request = Request.Builder()
  .url("{{baseUrl}}/2021-11-15/functions/:FunctionName/response-streaming-invocations")
  .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/2021-11-15/functions/:FunctionName/response-streaming-invocations',
  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: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2021-11-15/functions/:FunctionName/response-streaming-invocations',
  headers: {'content-type': 'application/json'},
  body: {Payload: ''},
  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}}/2021-11-15/functions/:FunctionName/response-streaming-invocations');

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

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

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}}/2021-11-15/functions/:FunctionName/response-streaming-invocations',
  headers: {'content-type': 'application/json'},
  data: {Payload: ''}
};

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

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

const url = '{{baseUrl}}/2021-11-15/functions/:FunctionName/response-streaming-invocations';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Payload":""}'
};

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2021-11-15/functions/:FunctionName/response-streaming-invocations"]
                                                       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}}/2021-11-15/functions/:FunctionName/response-streaming-invocations" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Payload\": \"\"\n}" in

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

 "{{baseUrl}}/2021-11-15/functions/:FunctionName/response-streaming-invocations",
  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' => ''
  ]),
  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}}/2021-11-15/functions/:FunctionName/response-streaming-invocations', [
  'body' => '{
  "Payload": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2021-11-15/functions/:FunctionName/response-streaming-invocations');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'Payload' => ''
]));
$request->setRequestUrl('{{baseUrl}}/2021-11-15/functions/:FunctionName/response-streaming-invocations');
$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}}/2021-11-15/functions/:FunctionName/response-streaming-invocations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Payload": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2021-11-15/functions/:FunctionName/response-streaming-invocations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Payload": ""
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/2021-11-15/functions/:FunctionName/response-streaming-invocations", payload, headers)

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

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

import requests

url = "{{baseUrl}}/2021-11-15/functions/:FunctionName/response-streaming-invocations"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/2021-11-15/functions/:FunctionName/response-streaming-invocations"

payload <- "{\n  \"Payload\": \"\"\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}}/2021-11-15/functions/:FunctionName/response-streaming-invocations")

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}"

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/2021-11-15/functions/:FunctionName/response-streaming-invocations') do |req|
  req.body = "{\n  \"Payload\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2021-11-15/functions/:FunctionName/response-streaming-invocations";

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

    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": ""
}' |  \
  http POST {{baseUrl}}/2021-11-15/functions/:FunctionName/response-streaming-invocations \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Payload": ""\n}' \
  --output-document \
  - {{baseUrl}}/2021-11-15/functions/:FunctionName/response-streaming-invocations

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2021-11-15/functions/:FunctionName/response-streaming-invocations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases")

require "http/client"

url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/aliases"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-03-31/functions/:FunctionName/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/2015-03-31/functions/:FunctionName/aliases HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/aliases")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/aliases');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases'
};

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

const url = '{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/aliases',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/aliases'
};

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

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

const url = '{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/aliases" in

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

 "{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/aliases');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases' -Method GET 

import http.client

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

conn.request("GET", "/baseUrl/2015-03-31/functions/:FunctionName/aliases")

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

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

import requests

url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-03-31/functions/:FunctionName/aliases"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-03-31/functions/:FunctionName/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/2015-03-31/functions/:FunctionName/aliases') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/aliases

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-03-31/functions/:FunctionName/aliases

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2020-04-22/code-signing-configs/");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2020-04-22/code-signing-configs/")

require "http/client"

url = "{{baseUrl}}/2020-04-22/code-signing-configs/"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/2020-04-22/code-signing-configs/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2020-04-22/code-signing-configs/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2020-04-22/code-signing-configs/"

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

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

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

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

}

GET /baseUrl/2020-04-22/code-signing-configs/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2020-04-22/code-signing-configs/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2020-04-22/code-signing-configs/"))
    .method("GET", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/2020-04-22/code-signing-configs/")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2020-04-22/code-signing-configs/")
  .asString();

const data = null;

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

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

xhr.open('GET', '{{baseUrl}}/2020-04-22/code-signing-configs/');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2020-04-22/code-signing-configs/'
};

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

const url = '{{baseUrl}}/2020-04-22/code-signing-configs/';
const options = {method: 'GET'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/2020-04-22/code-signing-configs/',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2020-04-22/code-signing-configs/")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2020-04-22/code-signing-configs/',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2020-04-22/code-signing-configs/'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/2020-04-22/code-signing-configs/');

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

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

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

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2020-04-22/code-signing-configs/'
};

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

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

const url = '{{baseUrl}}/2020-04-22/code-signing-configs/';
const options = {method: 'GET'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2020-04-22/code-signing-configs/"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/2020-04-22/code-signing-configs/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2020-04-22/code-signing-configs/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('GET', '{{baseUrl}}/2020-04-22/code-signing-configs/');

echo $response->getBody();

setUrl('{{baseUrl}}/2020-04-22/code-signing-configs/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/2020-04-22/code-signing-configs/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2020-04-22/code-signing-configs/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2020-04-22/code-signing-configs/' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/2020-04-22/code-signing-configs/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2020-04-22/code-signing-configs/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2020-04-22/code-signing-configs/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2020-04-22/code-signing-configs/")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.get('/baseUrl/2020-04-22/code-signing-configs/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2020-04-22/code-signing-configs/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/2020-04-22/code-signing-configs/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2020-04-22/code-signing-configs/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2020-04-22/code-signing-configs/")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-03-31/event-source-mappings/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/2015-03-31/event-source-mappings/")

require "http/client"

url = "{{baseUrl}}/2015-03-31/event-source-mappings/"

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}}/2015-03-31/event-source-mappings/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2015-03-31/event-source-mappings/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2015-03-31/event-source-mappings/"

	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/2015-03-31/event-source-mappings/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-03-31/event-source-mappings/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-03-31/event-source-mappings/"))
    .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}}/2015-03-31/event-source-mappings/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/2015-03-31/event-source-mappings/")
  .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}}/2015-03-31/event-source-mappings/');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-03-31/event-source-mappings/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2015-03-31/event-source-mappings/';
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}}/2015-03-31/event-source-mappings/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-03-31/event-source-mappings/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-03-31/event-source-mappings/',
  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}}/2015-03-31/event-source-mappings/'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/2015-03-31/event-source-mappings/');

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}}/2015-03-31/event-source-mappings/'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2015-03-31/event-source-mappings/';
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}}/2015-03-31/event-source-mappings/"]
                                                       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}}/2015-03-31/event-source-mappings/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2015-03-31/event-source-mappings/",
  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}}/2015-03-31/event-source-mappings/');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-03-31/event-source-mappings/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/2015-03-31/event-source-mappings/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-03-31/event-source-mappings/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-03-31/event-source-mappings/' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/2015-03-31/event-source-mappings/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2015-03-31/event-source-mappings/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-03-31/event-source-mappings/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-03-31/event-source-mappings/")

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/2015-03-31/event-source-mappings/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-03-31/event-source-mappings/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/2015-03-31/event-source-mappings/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-03-31/event-source-mappings/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-03-31/event-source-mappings/")! 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}}/2019-09-25/functions/:FunctionName/event-invoke-config/list");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config/list")

require "http/client"

url = "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config/list"

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}}/2019-09-25/functions/:FunctionName/event-invoke-config/list"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config/list");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config/list"

	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/2019-09-25/functions/:FunctionName/event-invoke-config/list HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config/list")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config/list"))
    .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}}/2019-09-25/functions/:FunctionName/event-invoke-config/list")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config/list")
  .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}}/2019-09-25/functions/:FunctionName/event-invoke-config/list');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config/list'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config/list';
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}}/2019-09-25/functions/:FunctionName/event-invoke-config/list',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config/list")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2019-09-25/functions/:FunctionName/event-invoke-config/list',
  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}}/2019-09-25/functions/:FunctionName/event-invoke-config/list'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config/list');

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}}/2019-09-25/functions/:FunctionName/event-invoke-config/list'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config/list';
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}}/2019-09-25/functions/:FunctionName/event-invoke-config/list"]
                                                       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}}/2019-09-25/functions/:FunctionName/event-invoke-config/list" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config/list",
  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}}/2019-09-25/functions/:FunctionName/event-invoke-config/list');

echo $response->getBody();

setUrl('{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config/list');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config/list');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config/list' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config/list' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/2019-09-25/functions/:FunctionName/event-invoke-config/list")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config/list"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config/list"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config/list")

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/2019-09-25/functions/:FunctionName/event-invoke-config/list') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config/list";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config/list

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config/list

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config/list")! 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}}/2021-10-31/functions/:FunctionName/urls");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/2021-10-31/functions/:FunctionName/urls")

require "http/client"

url = "{{baseUrl}}/2021-10-31/functions/:FunctionName/urls"

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}}/2021-10-31/functions/:FunctionName/urls"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2021-10-31/functions/:FunctionName/urls");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2021-10-31/functions/:FunctionName/urls"

	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/2021-10-31/functions/:FunctionName/urls HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2021-10-31/functions/:FunctionName/urls")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2021-10-31/functions/:FunctionName/urls"))
    .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}}/2021-10-31/functions/:FunctionName/urls")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/2021-10-31/functions/:FunctionName/urls")
  .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}}/2021-10-31/functions/:FunctionName/urls');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2021-10-31/functions/:FunctionName/urls'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2021-10-31/functions/:FunctionName/urls';
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}}/2021-10-31/functions/:FunctionName/urls',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2021-10-31/functions/:FunctionName/urls")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2021-10-31/functions/:FunctionName/urls',
  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}}/2021-10-31/functions/:FunctionName/urls'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/2021-10-31/functions/:FunctionName/urls');

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}}/2021-10-31/functions/:FunctionName/urls'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2021-10-31/functions/:FunctionName/urls';
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}}/2021-10-31/functions/:FunctionName/urls"]
                                                       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}}/2021-10-31/functions/:FunctionName/urls" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2021-10-31/functions/:FunctionName/urls",
  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}}/2021-10-31/functions/:FunctionName/urls');

echo $response->getBody();

setUrl('{{baseUrl}}/2021-10-31/functions/:FunctionName/urls');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/2021-10-31/functions/:FunctionName/urls');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2021-10-31/functions/:FunctionName/urls' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2021-10-31/functions/:FunctionName/urls' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/2021-10-31/functions/:FunctionName/urls")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2021-10-31/functions/:FunctionName/urls"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2021-10-31/functions/:FunctionName/urls"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2021-10-31/functions/:FunctionName/urls")

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/2021-10-31/functions/:FunctionName/urls') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2021-10-31/functions/:FunctionName/urls";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/2021-10-31/functions/:FunctionName/urls

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2021-10-31/functions/:FunctionName/urls

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2021-10-31/functions/:FunctionName/urls")! 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}}/2015-03-31/functions/");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/2015-03-31/functions/")

require "http/client"

url = "{{baseUrl}}/2015-03-31/functions/"

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}}/2015-03-31/functions/"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2015-03-31/functions/");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2015-03-31/functions/"

	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/2015-03-31/functions/ HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-03-31/functions/")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-03-31/functions/"))
    .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}}/2015-03-31/functions/")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/2015-03-31/functions/")
  .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}}/2015-03-31/functions/');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/2015-03-31/functions/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2015-03-31/functions/';
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}}/2015-03-31/functions/',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-03-31/functions/")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-03-31/functions/',
  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}}/2015-03-31/functions/'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/2015-03-31/functions/');

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}}/2015-03-31/functions/'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2015-03-31/functions/';
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}}/2015-03-31/functions/"]
                                                       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}}/2015-03-31/functions/" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2015-03-31/functions/",
  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}}/2015-03-31/functions/');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-03-31/functions/');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/2015-03-31/functions/');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-03-31/functions/' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-03-31/functions/' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/2015-03-31/functions/")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2015-03-31/functions/"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-03-31/functions/"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-03-31/functions/")

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/2015-03-31/functions/') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-03-31/functions/";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/2015-03-31/functions/

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-03-31/functions/

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-03-31/functions/")! 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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions")

require "http/client"

url = "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions"

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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions"

	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/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions"))
    .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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions")
  .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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions';
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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions',
  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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions');

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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions';
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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions"]
                                                       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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions",
  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}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions');

echo $response->getBody();

setUrl('{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions")

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/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2020-04-22/code-signing-configs/:CodeSigningConfigArn/functions")! 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}}/2018-10-31/layers/:LayerName/versions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/2018-10-31/layers/:LayerName/versions")

require "http/client"

url = "{{baseUrl}}/2018-10-31/layers/:LayerName/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}}/2018-10-31/layers/:LayerName/versions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2018-10-31/layers/:LayerName/versions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2018-10-31/layers/:LayerName/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/2018-10-31/layers/:LayerName/versions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2018-10-31/layers/:LayerName/versions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2018-10-31/layers/:LayerName/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}}/2018-10-31/layers/:LayerName/versions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/2018-10-31/layers/:LayerName/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}}/2018-10-31/layers/:LayerName/versions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2018-10-31/layers/:LayerName/versions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2018-10-31/layers/:LayerName/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}}/2018-10-31/layers/:LayerName/versions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2018-10-31/layers/:LayerName/versions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2018-10-31/layers/:LayerName/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}}/2018-10-31/layers/:LayerName/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}}/2018-10-31/layers/:LayerName/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}}/2018-10-31/layers/:LayerName/versions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2018-10-31/layers/:LayerName/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}}/2018-10-31/layers/:LayerName/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}}/2018-10-31/layers/:LayerName/versions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2018-10-31/layers/:LayerName/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}}/2018-10-31/layers/:LayerName/versions');

echo $response->getBody();

setUrl('{{baseUrl}}/2018-10-31/layers/:LayerName/versions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/2018-10-31/layers/:LayerName/versions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2018-10-31/layers/:LayerName/versions' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2018-10-31/layers/:LayerName/versions' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/2018-10-31/layers/:LayerName/versions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2018-10-31/layers/:LayerName/versions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2018-10-31/layers/:LayerName/versions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2018-10-31/layers/:LayerName/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/2018-10-31/layers/:LayerName/versions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2018-10-31/layers/:LayerName/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}}/2018-10-31/layers/:LayerName/versions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2018-10-31/layers/:LayerName/versions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2018-10-31/layers/:LayerName/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}}/2018-10-31/layers");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/2018-10-31/layers")

require "http/client"

url = "{{baseUrl}}/2018-10-31/layers"

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}}/2018-10-31/layers"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2018-10-31/layers");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2018-10-31/layers"

	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/2018-10-31/layers HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2018-10-31/layers")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2018-10-31/layers"))
    .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}}/2018-10-31/layers")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/2018-10-31/layers")
  .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}}/2018-10-31/layers');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/2018-10-31/layers'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2018-10-31/layers';
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}}/2018-10-31/layers',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2018-10-31/layers")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2018-10-31/layers',
  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}}/2018-10-31/layers'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/2018-10-31/layers');

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}}/2018-10-31/layers'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2018-10-31/layers';
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}}/2018-10-31/layers"]
                                                       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}}/2018-10-31/layers" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2018-10-31/layers",
  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}}/2018-10-31/layers');

echo $response->getBody();

setUrl('{{baseUrl}}/2018-10-31/layers');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/2018-10-31/layers');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2018-10-31/layers' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2018-10-31/layers' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/2018-10-31/layers")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2018-10-31/layers"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2018-10-31/layers"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2018-10-31/layers")

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/2018-10-31/layers') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2018-10-31/layers";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/2018-10-31/layers

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2018-10-31/layers

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2018-10-31/layers")! 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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?List=#List=ALL");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#List=ALL" {:query-params {:List ""}})

require "http/client"

url = "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?List=#List=ALL"

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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?List=#List=ALL"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?List=#List=ALL");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?List=#List=ALL"

	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/2019-09-30/functions/:FunctionName/provisioned-concurrency?List= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?List=#List=ALL")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?List=#List=ALL"))
    .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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?List=#List=ALL")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?List=#List=ALL")
  .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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?List=#List=ALL');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#List=ALL',
  params: {List: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?List=#List=ALL';
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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?List=#List=ALL',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?List=#List=ALL")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2019-09-30/functions/:FunctionName/provisioned-concurrency?List=',
  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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#List=ALL',
  qs: {List: ''}
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#List=ALL');

req.query({
  List: ''
});

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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#List=ALL',
  params: {List: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?List=#List=ALL';
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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?List=#List=ALL"]
                                                       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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?List=#List=ALL" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?List=#List=ALL",
  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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?List=#List=ALL');

echo $response->getBody();

setUrl('{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#List=ALL');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'List' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#List=ALL');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'List' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?List=#List=ALL' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?List=#List=ALL' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/2019-09-30/functions/:FunctionName/provisioned-concurrency?List=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#List=ALL"

querystring = {"List":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#List=ALL"

queryString <- list(List = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?List=#List=ALL")

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/2019-09-30/functions/:FunctionName/provisioned-concurrency') do |req|
  req.params['List'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#List=ALL";

    let querystring = [
        ("List", ""),
    ];

    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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?List=#List=ALL'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?List=#List=ALL'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?List=#List=ALL")! 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}}/2017-03-31/tags/:ARN");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/2017-03-31/tags/:ARN")

require "http/client"

url = "{{baseUrl}}/2017-03-31/tags/:ARN"

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}}/2017-03-31/tags/:ARN"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2017-03-31/tags/:ARN");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2017-03-31/tags/:ARN"

	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/2017-03-31/tags/:ARN HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2017-03-31/tags/:ARN")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2017-03-31/tags/:ARN"))
    .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}}/2017-03-31/tags/:ARN")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/2017-03-31/tags/:ARN")
  .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}}/2017-03-31/tags/:ARN');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/2017-03-31/tags/:ARN'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2017-03-31/tags/:ARN';
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}}/2017-03-31/tags/:ARN',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2017-03-31/tags/:ARN")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2017-03-31/tags/:ARN',
  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}}/2017-03-31/tags/:ARN'};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('GET', '{{baseUrl}}/2017-03-31/tags/:ARN');

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}}/2017-03-31/tags/:ARN'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2017-03-31/tags/:ARN';
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}}/2017-03-31/tags/:ARN"]
                                                       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}}/2017-03-31/tags/:ARN" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2017-03-31/tags/:ARN",
  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}}/2017-03-31/tags/:ARN');

echo $response->getBody();

setUrl('{{baseUrl}}/2017-03-31/tags/:ARN');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/2017-03-31/tags/:ARN');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2017-03-31/tags/:ARN' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2017-03-31/tags/:ARN' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/2017-03-31/tags/:ARN")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2017-03-31/tags/:ARN"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2017-03-31/tags/:ARN"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2017-03-31/tags/:ARN")

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/2017-03-31/tags/:ARN') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2017-03-31/tags/:ARN";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

http GET {{baseUrl}}/2017-03-31/tags/:ARN

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2017-03-31/tags/:ARN

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2017-03-31/tags/:ARN")! 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}}/2015-03-31/functions/:FunctionName/versions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/2015-03-31/functions/:FunctionName/versions")

require "http/client"

url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/versions"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2015-03-31/functions/:FunctionName/versions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2015-03-31/functions/:FunctionName/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/2015-03-31/functions/:FunctionName/versions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-03-31/functions/:FunctionName/versions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/versions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/versions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-03-31/functions/:FunctionName/versions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/versions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-03-31/functions/:FunctionName/versions")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/versions'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/versions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/versions');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-03-31/functions/:FunctionName/versions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/2015-03-31/functions/:FunctionName/versions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-03-31/functions/:FunctionName/versions' -Method GET 

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-03-31/functions/:FunctionName/versions' -Method GET 

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/2015-03-31/functions/:FunctionName/versions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/versions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-03-31/functions/:FunctionName/versions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-03-31/functions/:FunctionName/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/2015-03-31/functions/:FunctionName/versions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/versions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-03-31/functions/:FunctionName/versions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-03-31/functions/:FunctionName/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, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2018-10-31/layers/:LayerName/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  \"Description\": \"\",\n  \"Content\": {\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ZipFile\": \"\"\n  },\n  \"CompatibleRuntimes\": [],\n  \"LicenseInfo\": \"\",\n  \"CompatibleArchitectures\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/2018-10-31/layers/:LayerName/versions" {:content-type :json
                                                                                  :form-params {:Description ""
                                                                                                :Content {:S3Bucket ""
                                                                                                          :S3Key ""
                                                                                                          :S3ObjectVersion ""
                                                                                                          :ZipFile ""}
                                                                                                :CompatibleRuntimes []
                                                                                                :LicenseInfo ""
                                                                                                :CompatibleArchitectures []}})

require "http/client"

url = "{{baseUrl}}/2018-10-31/layers/:LayerName/versions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Description\": \"\",\n  \"Content\": {\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ZipFile\": \"\"\n  },\n  \"CompatibleRuntimes\": [],\n  \"LicenseInfo\": \"\",\n  \"CompatibleArchitectures\": []\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}}/2018-10-31/layers/:LayerName/versions"),
    Content = new StringContent("{\n  \"Description\": \"\",\n  \"Content\": {\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ZipFile\": \"\"\n  },\n  \"CompatibleRuntimes\": [],\n  \"LicenseInfo\": \"\",\n  \"CompatibleArchitectures\": []\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}}/2018-10-31/layers/:LayerName/versions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Description\": \"\",\n  \"Content\": {\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ZipFile\": \"\"\n  },\n  \"CompatibleRuntimes\": [],\n  \"LicenseInfo\": \"\",\n  \"CompatibleArchitectures\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2018-10-31/layers/:LayerName/versions"

	payload := strings.NewReader("{\n  \"Description\": \"\",\n  \"Content\": {\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ZipFile\": \"\"\n  },\n  \"CompatibleRuntimes\": [],\n  \"LicenseInfo\": \"\",\n  \"CompatibleArchitectures\": []\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/2018-10-31/layers/:LayerName/versions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 207

{
  "Description": "",
  "Content": {
    "S3Bucket": "",
    "S3Key": "",
    "S3ObjectVersion": "",
    "ZipFile": ""
  },
  "CompatibleRuntimes": [],
  "LicenseInfo": "",
  "CompatibleArchitectures": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2018-10-31/layers/:LayerName/versions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Description\": \"\",\n  \"Content\": {\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ZipFile\": \"\"\n  },\n  \"CompatibleRuntimes\": [],\n  \"LicenseInfo\": \"\",\n  \"CompatibleArchitectures\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2018-10-31/layers/:LayerName/versions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Description\": \"\",\n  \"Content\": {\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ZipFile\": \"\"\n  },\n  \"CompatibleRuntimes\": [],\n  \"LicenseInfo\": \"\",\n  \"CompatibleArchitectures\": []\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  \"Content\": {\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ZipFile\": \"\"\n  },\n  \"CompatibleRuntimes\": [],\n  \"LicenseInfo\": \"\",\n  \"CompatibleArchitectures\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2018-10-31/layers/:LayerName/versions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/2018-10-31/layers/:LayerName/versions")
  .header("content-type", "application/json")
  .body("{\n  \"Description\": \"\",\n  \"Content\": {\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ZipFile\": \"\"\n  },\n  \"CompatibleRuntimes\": [],\n  \"LicenseInfo\": \"\",\n  \"CompatibleArchitectures\": []\n}")
  .asString();

const data = JSON.stringify({
  Description: '',
  Content: {
    S3Bucket: '',
    S3Key: '',
    S3ObjectVersion: '',
    ZipFile: ''
  },
  CompatibleRuntimes: [],
  LicenseInfo: '',
  CompatibleArchitectures: []
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/2018-10-31/layers/:LayerName/versions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2018-10-31/layers/:LayerName/versions',
  headers: {'content-type': 'application/json'},
  data: {
    Description: '',
    Content: {S3Bucket: '', S3Key: '', S3ObjectVersion: '', ZipFile: ''},
    CompatibleRuntimes: [],
    LicenseInfo: '',
    CompatibleArchitectures: []
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2018-10-31/layers/:LayerName/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Description":"","Content":{"S3Bucket":"","S3Key":"","S3ObjectVersion":"","ZipFile":""},"CompatibleRuntimes":[],"LicenseInfo":"","CompatibleArchitectures":[]}'
};

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}}/2018-10-31/layers/:LayerName/versions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Description": "",\n  "Content": {\n    "S3Bucket": "",\n    "S3Key": "",\n    "S3ObjectVersion": "",\n    "ZipFile": ""\n  },\n  "CompatibleRuntimes": [],\n  "LicenseInfo": "",\n  "CompatibleArchitectures": []\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  \"Content\": {\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ZipFile\": \"\"\n  },\n  \"CompatibleRuntimes\": [],\n  \"LicenseInfo\": \"\",\n  \"CompatibleArchitectures\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2018-10-31/layers/:LayerName/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/2018-10-31/layers/:LayerName/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({
  Description: '',
  Content: {S3Bucket: '', S3Key: '', S3ObjectVersion: '', ZipFile: ''},
  CompatibleRuntimes: [],
  LicenseInfo: '',
  CompatibleArchitectures: []
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2018-10-31/layers/:LayerName/versions',
  headers: {'content-type': 'application/json'},
  body: {
    Description: '',
    Content: {S3Bucket: '', S3Key: '', S3ObjectVersion: '', ZipFile: ''},
    CompatibleRuntimes: [],
    LicenseInfo: '',
    CompatibleArchitectures: []
  },
  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}}/2018-10-31/layers/:LayerName/versions');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Description: '',
  Content: {
    S3Bucket: '',
    S3Key: '',
    S3ObjectVersion: '',
    ZipFile: ''
  },
  CompatibleRuntimes: [],
  LicenseInfo: '',
  CompatibleArchitectures: []
});

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}}/2018-10-31/layers/:LayerName/versions',
  headers: {'content-type': 'application/json'},
  data: {
    Description: '',
    Content: {S3Bucket: '', S3Key: '', S3ObjectVersion: '', ZipFile: ''},
    CompatibleRuntimes: [],
    LicenseInfo: '',
    CompatibleArchitectures: []
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2018-10-31/layers/:LayerName/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Description":"","Content":{"S3Bucket":"","S3Key":"","S3ObjectVersion":"","ZipFile":""},"CompatibleRuntimes":[],"LicenseInfo":"","CompatibleArchitectures":[]}'
};

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": @"",
                              @"Content": @{ @"S3Bucket": @"", @"S3Key": @"", @"S3ObjectVersion": @"", @"ZipFile": @"" },
                              @"CompatibleRuntimes": @[  ],
                              @"LicenseInfo": @"",
                              @"CompatibleArchitectures": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2018-10-31/layers/:LayerName/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}}/2018-10-31/layers/:LayerName/versions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Description\": \"\",\n  \"Content\": {\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ZipFile\": \"\"\n  },\n  \"CompatibleRuntimes\": [],\n  \"LicenseInfo\": \"\",\n  \"CompatibleArchitectures\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2018-10-31/layers/:LayerName/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([
    'Description' => '',
    'Content' => [
        'S3Bucket' => '',
        'S3Key' => '',
        'S3ObjectVersion' => '',
        'ZipFile' => ''
    ],
    'CompatibleRuntimes' => [
        
    ],
    'LicenseInfo' => '',
    'CompatibleArchitectures' => [
        
    ]
  ]),
  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}}/2018-10-31/layers/:LayerName/versions', [
  'body' => '{
  "Description": "",
  "Content": {
    "S3Bucket": "",
    "S3Key": "",
    "S3ObjectVersion": "",
    "ZipFile": ""
  },
  "CompatibleRuntimes": [],
  "LicenseInfo": "",
  "CompatibleArchitectures": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2018-10-31/layers/:LayerName/versions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Description' => '',
  'Content' => [
    'S3Bucket' => '',
    'S3Key' => '',
    'S3ObjectVersion' => '',
    'ZipFile' => ''
  ],
  'CompatibleRuntimes' => [
    
  ],
  'LicenseInfo' => '',
  'CompatibleArchitectures' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Description' => '',
  'Content' => [
    'S3Bucket' => '',
    'S3Key' => '',
    'S3ObjectVersion' => '',
    'ZipFile' => ''
  ],
  'CompatibleRuntimes' => [
    
  ],
  'LicenseInfo' => '',
  'CompatibleArchitectures' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/2018-10-31/layers/:LayerName/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}}/2018-10-31/layers/:LayerName/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Description": "",
  "Content": {
    "S3Bucket": "",
    "S3Key": "",
    "S3ObjectVersion": "",
    "ZipFile": ""
  },
  "CompatibleRuntimes": [],
  "LicenseInfo": "",
  "CompatibleArchitectures": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2018-10-31/layers/:LayerName/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Description": "",
  "Content": {
    "S3Bucket": "",
    "S3Key": "",
    "S3ObjectVersion": "",
    "ZipFile": ""
  },
  "CompatibleRuntimes": [],
  "LicenseInfo": "",
  "CompatibleArchitectures": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Description\": \"\",\n  \"Content\": {\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ZipFile\": \"\"\n  },\n  \"CompatibleRuntimes\": [],\n  \"LicenseInfo\": \"\",\n  \"CompatibleArchitectures\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/2018-10-31/layers/:LayerName/versions", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2018-10-31/layers/:LayerName/versions"

payload = {
    "Description": "",
    "Content": {
        "S3Bucket": "",
        "S3Key": "",
        "S3ObjectVersion": "",
        "ZipFile": ""
    },
    "CompatibleRuntimes": [],
    "LicenseInfo": "",
    "CompatibleArchitectures": []
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2018-10-31/layers/:LayerName/versions"

payload <- "{\n  \"Description\": \"\",\n  \"Content\": {\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ZipFile\": \"\"\n  },\n  \"CompatibleRuntimes\": [],\n  \"LicenseInfo\": \"\",\n  \"CompatibleArchitectures\": []\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}}/2018-10-31/layers/:LayerName/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  \"Description\": \"\",\n  \"Content\": {\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ZipFile\": \"\"\n  },\n  \"CompatibleRuntimes\": [],\n  \"LicenseInfo\": \"\",\n  \"CompatibleArchitectures\": []\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/2018-10-31/layers/:LayerName/versions') do |req|
  req.body = "{\n  \"Description\": \"\",\n  \"Content\": {\n    \"S3Bucket\": \"\",\n    \"S3Key\": \"\",\n    \"S3ObjectVersion\": \"\",\n    \"ZipFile\": \"\"\n  },\n  \"CompatibleRuntimes\": [],\n  \"LicenseInfo\": \"\",\n  \"CompatibleArchitectures\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2018-10-31/layers/:LayerName/versions";

    let payload = json!({
        "Description": "",
        "Content": json!({
            "S3Bucket": "",
            "S3Key": "",
            "S3ObjectVersion": "",
            "ZipFile": ""
        }),
        "CompatibleRuntimes": (),
        "LicenseInfo": "",
        "CompatibleArchitectures": ()
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "Description": "",
  "Content": {
    "S3Bucket": "",
    "S3Key": "",
    "S3ObjectVersion": "",
    "ZipFile": ""
  },
  "CompatibleRuntimes": [],
  "LicenseInfo": "",
  "CompatibleArchitectures": []
}' |  \
  http POST {{baseUrl}}/2018-10-31/layers/:LayerName/versions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Description": "",\n  "Content": {\n    "S3Bucket": "",\n    "S3Key": "",\n    "S3ObjectVersion": "",\n    "ZipFile": ""\n  },\n  "CompatibleRuntimes": [],\n  "LicenseInfo": "",\n  "CompatibleArchitectures": []\n}' \
  --output-document \
  - {{baseUrl}}/2018-10-31/layers/:LayerName/versions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Description": "",
  "Content": [
    "S3Bucket": "",
    "S3Key": "",
    "S3ObjectVersion": "",
    "ZipFile": ""
  ],
  "CompatibleRuntimes": [],
  "LicenseInfo": "",
  "CompatibleArchitectures": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2018-10-31/layers/:LayerName/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}}/2015-03-31/functions/:FunctionName/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  \"CodeSha256\": \"\",\n  \"Description\": \"\",\n  \"RevisionId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/2015-03-31/functions/:FunctionName/versions" {:content-type :json
                                                                                        :form-params {:CodeSha256 ""
                                                                                                      :Description ""
                                                                                                      :RevisionId ""}})

require "http/client"

url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/versions"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"CodeSha256\": \"\",\n  \"Description\": \"\",\n  \"RevisionId\": \"\"\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}}/2015-03-31/functions/:FunctionName/versions"),
    Content = new StringContent("{\n  \"CodeSha256\": \"\",\n  \"Description\": \"\",\n  \"RevisionId\": \"\"\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}}/2015-03-31/functions/:FunctionName/versions");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"CodeSha256\": \"\",\n  \"Description\": \"\",\n  \"RevisionId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2015-03-31/functions/:FunctionName/versions"

	payload := strings.NewReader("{\n  \"CodeSha256\": \"\",\n  \"Description\": \"\",\n  \"RevisionId\": \"\"\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/2015-03-31/functions/:FunctionName/versions HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 63

{
  "CodeSha256": "",
  "Description": "",
  "RevisionId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-03-31/functions/:FunctionName/versions")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"CodeSha256\": \"\",\n  \"Description\": \"\",\n  \"RevisionId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-03-31/functions/:FunctionName/versions"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CodeSha256\": \"\",\n  \"Description\": \"\",\n  \"RevisionId\": \"\"\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  \"CodeSha256\": \"\",\n  \"Description\": \"\",\n  \"RevisionId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-03-31/functions/:FunctionName/versions")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/2015-03-31/functions/:FunctionName/versions")
  .header("content-type", "application/json")
  .body("{\n  \"CodeSha256\": \"\",\n  \"Description\": \"\",\n  \"RevisionId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  CodeSha256: '',
  Description: '',
  RevisionId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/2015-03-31/functions/:FunctionName/versions');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-03-31/functions/:FunctionName/versions',
  headers: {'content-type': 'application/json'},
  data: {CodeSha256: '', Description: '', RevisionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2015-03-31/functions/:FunctionName/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"CodeSha256":"","Description":"","RevisionId":""}'
};

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}}/2015-03-31/functions/:FunctionName/versions',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CodeSha256": "",\n  "Description": "",\n  "RevisionId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CodeSha256\": \"\",\n  \"Description\": \"\",\n  \"RevisionId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2015-03-31/functions/:FunctionName/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/2015-03-31/functions/:FunctionName/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({CodeSha256: '', Description: '', RevisionId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-03-31/functions/:FunctionName/versions',
  headers: {'content-type': 'application/json'},
  body: {CodeSha256: '', Description: '', RevisionId: ''},
  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}}/2015-03-31/functions/:FunctionName/versions');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  CodeSha256: '',
  Description: '',
  RevisionId: ''
});

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}}/2015-03-31/functions/:FunctionName/versions',
  headers: {'content-type': 'application/json'},
  data: {CodeSha256: '', Description: '', RevisionId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2015-03-31/functions/:FunctionName/versions';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"CodeSha256":"","Description":"","RevisionId":""}'
};

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 = @{ @"CodeSha256": @"",
                              @"Description": @"",
                              @"RevisionId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/versions" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"CodeSha256\": \"\",\n  \"Description\": \"\",\n  \"RevisionId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2015-03-31/functions/:FunctionName/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([
    'CodeSha256' => '',
    'Description' => '',
    'RevisionId' => ''
  ]),
  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}}/2015-03-31/functions/:FunctionName/versions', [
  'body' => '{
  "CodeSha256": "",
  "Description": "",
  "RevisionId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2015-03-31/functions/:FunctionName/versions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CodeSha256' => '',
  'Description' => '',
  'RevisionId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'CodeSha256' => '',
  'Description' => '',
  'RevisionId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/2015-03-31/functions/:FunctionName/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}}/2015-03-31/functions/:FunctionName/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CodeSha256": "",
  "Description": "",
  "RevisionId": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-03-31/functions/:FunctionName/versions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CodeSha256": "",
  "Description": "",
  "RevisionId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"CodeSha256\": \"\",\n  \"Description\": \"\",\n  \"RevisionId\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/2015-03-31/functions/:FunctionName/versions", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/versions"

payload = {
    "CodeSha256": "",
    "Description": "",
    "RevisionId": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-03-31/functions/:FunctionName/versions"

payload <- "{\n  \"CodeSha256\": \"\",\n  \"Description\": \"\",\n  \"RevisionId\": \"\"\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}}/2015-03-31/functions/:FunctionName/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  \"CodeSha256\": \"\",\n  \"Description\": \"\",\n  \"RevisionId\": \"\"\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/2015-03-31/functions/:FunctionName/versions') do |req|
  req.body = "{\n  \"CodeSha256\": \"\",\n  \"Description\": \"\",\n  \"RevisionId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-03-31/functions/:FunctionName/versions";

    let payload = json!({
        "CodeSha256": "",
        "Description": "",
        "RevisionId": ""
    });

    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 '{
  "CodeSha256": "",
  "Description": "",
  "RevisionId": ""
}' |  \
  http POST {{baseUrl}}/2015-03-31/functions/:FunctionName/versions \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "CodeSha256": "",\n  "Description": "",\n  "RevisionId": ""\n}' \
  --output-document \
  - {{baseUrl}}/2015-03-31/functions/:FunctionName/versions

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "CodeSha256": "",
  "Description": "",
  "RevisionId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-03-31/functions/:FunctionName/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, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"CodeSigningConfigArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config" {:content-type :json
                                                                                                  :form-params {:CodeSigningConfigArn ""}})

require "http/client"

url = "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"CodeSigningConfigArn\": \"\"\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}}/2020-06-30/functions/:FunctionName/code-signing-config"),
    Content = new StringContent("{\n  \"CodeSigningConfigArn\": \"\"\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}}/2020-06-30/functions/:FunctionName/code-signing-config");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"CodeSigningConfigArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config"

	payload := strings.NewReader("{\n  \"CodeSigningConfigArn\": \"\"\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/2020-06-30/functions/:FunctionName/code-signing-config HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 32

{
  "CodeSigningConfigArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"CodeSigningConfigArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"CodeSigningConfigArn\": \"\"\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  \"CodeSigningConfigArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config")
  .header("content-type", "application/json")
  .body("{\n  \"CodeSigningConfigArn\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  CodeSigningConfigArn: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config',
  headers: {'content-type': 'application/json'},
  data: {CodeSigningConfigArn: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"CodeSigningConfigArn":""}'
};

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}}/2020-06-30/functions/:FunctionName/code-signing-config',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CodeSigningConfigArn": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CodeSigningConfigArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config")
  .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/2020-06-30/functions/:FunctionName/code-signing-config',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({CodeSigningConfigArn: ''}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config',
  headers: {'content-type': 'application/json'},
  body: {CodeSigningConfigArn: ''},
  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}}/2020-06-30/functions/:FunctionName/code-signing-config');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  CodeSigningConfigArn: ''
});

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}}/2020-06-30/functions/:FunctionName/code-signing-config',
  headers: {'content-type': 'application/json'},
  data: {CodeSigningConfigArn: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"CodeSigningConfigArn":""}'
};

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 = @{ @"CodeSigningConfigArn": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config"]
                                                       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}}/2020-06-30/functions/:FunctionName/code-signing-config" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"CodeSigningConfigArn\": \"\"\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config",
  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([
    'CodeSigningConfigArn' => ''
  ]),
  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}}/2020-06-30/functions/:FunctionName/code-signing-config', [
  'body' => '{
  "CodeSigningConfigArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CodeSigningConfigArn' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'CodeSigningConfigArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config');
$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}}/2020-06-30/functions/:FunctionName/code-signing-config' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "CodeSigningConfigArn": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "CodeSigningConfigArn": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"CodeSigningConfigArn\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/2020-06-30/functions/:FunctionName/code-signing-config", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config"

payload = { "CodeSigningConfigArn": "" }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config"

payload <- "{\n  \"CodeSigningConfigArn\": \"\"\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}}/2020-06-30/functions/:FunctionName/code-signing-config")

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  \"CodeSigningConfigArn\": \"\"\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/2020-06-30/functions/:FunctionName/code-signing-config') do |req|
  req.body = "{\n  \"CodeSigningConfigArn\": \"\"\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}}/2020-06-30/functions/:FunctionName/code-signing-config";

    let payload = json!({"CodeSigningConfigArn": ""});

    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 '{
  "CodeSigningConfigArn": ""
}' |  \
  http PUT {{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "CodeSigningConfigArn": ""\n}' \
  --output-document \
  - {{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["CodeSigningConfigArn": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2020-06-30/functions/:FunctionName/code-signing-config")! 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}}/2017-10-31/functions/:FunctionName/concurrency");

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  \"ReservedConcurrentExecutions\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency" {:content-type :json
                                                                                          :form-params {:ReservedConcurrentExecutions 0}})

require "http/client"

url = "{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ReservedConcurrentExecutions\": 0\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}}/2017-10-31/functions/:FunctionName/concurrency"),
    Content = new StringContent("{\n  \"ReservedConcurrentExecutions\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ReservedConcurrentExecutions\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency"

	payload := strings.NewReader("{\n  \"ReservedConcurrentExecutions\": 0\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/2017-10-31/functions/:FunctionName/concurrency HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 39

{
  "ReservedConcurrentExecutions": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ReservedConcurrentExecutions\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"ReservedConcurrentExecutions\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ReservedConcurrentExecutions\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency")
  .header("content-type", "application/json")
  .body("{\n  \"ReservedConcurrentExecutions\": 0\n}")
  .asString();

const data = JSON.stringify({
  ReservedConcurrentExecutions: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency',
  headers: {'content-type': 'application/json'},
  data: {ReservedConcurrentExecutions: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ReservedConcurrentExecutions":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ReservedConcurrentExecutions": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ReservedConcurrentExecutions\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency")
  .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/2017-10-31/functions/:FunctionName/concurrency',
  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({ReservedConcurrentExecutions: 0}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency',
  headers: {'content-type': 'application/json'},
  body: {ReservedConcurrentExecutions: 0},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ReservedConcurrentExecutions: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency',
  headers: {'content-type': 'application/json'},
  data: {ReservedConcurrentExecutions: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ReservedConcurrentExecutions":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ReservedConcurrentExecutions": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency"]
                                                       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}}/2017-10-31/functions/:FunctionName/concurrency" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ReservedConcurrentExecutions\": 0\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency",
  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([
    'ReservedConcurrentExecutions' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency', [
  'body' => '{
  "ReservedConcurrentExecutions": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ReservedConcurrentExecutions' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ReservedConcurrentExecutions' => 0
]));
$request->setRequestUrl('{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency');
$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}}/2017-10-31/functions/:FunctionName/concurrency' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ReservedConcurrentExecutions": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ReservedConcurrentExecutions": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ReservedConcurrentExecutions\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/2017-10-31/functions/:FunctionName/concurrency", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency"

payload = { "ReservedConcurrentExecutions": 0 }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency"

payload <- "{\n  \"ReservedConcurrentExecutions\": 0\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}}/2017-10-31/functions/:FunctionName/concurrency")

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  \"ReservedConcurrentExecutions\": 0\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/2017-10-31/functions/:FunctionName/concurrency') do |req|
  req.body = "{\n  \"ReservedConcurrentExecutions\": 0\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency";

    let payload = json!({"ReservedConcurrentExecutions": 0});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "ReservedConcurrentExecutions": 0
}' |  \
  http PUT {{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "ReservedConcurrentExecutions": 0\n}' \
  --output-document \
  - {{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["ReservedConcurrentExecutions": 0] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2017-10-31/functions/:FunctionName/concurrency")! 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}}/2019-09-25/functions/:FunctionName/event-invoke-config");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"MaximumRetryAttempts\": 0,\n  \"MaximumEventAgeInSeconds\": 0,\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config" {:content-type :json
                                                                                                  :form-params {:MaximumRetryAttempts 0
                                                                                                                :MaximumEventAgeInSeconds 0
                                                                                                                :DestinationConfig {:OnSuccess ""
                                                                                                                                    :OnFailure ""}}})

require "http/client"

url = "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"MaximumRetryAttempts\": 0,\n  \"MaximumEventAgeInSeconds\": 0,\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\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}}/2019-09-25/functions/:FunctionName/event-invoke-config"),
    Content = new StringContent("{\n  \"MaximumRetryAttempts\": 0,\n  \"MaximumEventAgeInSeconds\": 0,\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\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}}/2019-09-25/functions/:FunctionName/event-invoke-config");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"MaximumRetryAttempts\": 0,\n  \"MaximumEventAgeInSeconds\": 0,\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config"

	payload := strings.NewReader("{\n  \"MaximumRetryAttempts\": 0,\n  \"MaximumEventAgeInSeconds\": 0,\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\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/2019-09-25/functions/:FunctionName/event-invoke-config HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 135

{
  "MaximumRetryAttempts": 0,
  "MaximumEventAgeInSeconds": 0,
  "DestinationConfig": {
    "OnSuccess": "",
    "OnFailure": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"MaximumRetryAttempts\": 0,\n  \"MaximumEventAgeInSeconds\": 0,\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"MaximumRetryAttempts\": 0,\n  \"MaximumEventAgeInSeconds\": 0,\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\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  \"MaximumRetryAttempts\": 0,\n  \"MaximumEventAgeInSeconds\": 0,\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config")
  .header("content-type", "application/json")
  .body("{\n  \"MaximumRetryAttempts\": 0,\n  \"MaximumEventAgeInSeconds\": 0,\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  MaximumRetryAttempts: 0,
  MaximumEventAgeInSeconds: 0,
  DestinationConfig: {
    OnSuccess: '',
    OnFailure: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config',
  headers: {'content-type': 'application/json'},
  data: {
    MaximumRetryAttempts: 0,
    MaximumEventAgeInSeconds: 0,
    DestinationConfig: {OnSuccess: '', OnFailure: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"MaximumRetryAttempts":0,"MaximumEventAgeInSeconds":0,"DestinationConfig":{"OnSuccess":"","OnFailure":""}}'
};

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}}/2019-09-25/functions/:FunctionName/event-invoke-config',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "MaximumRetryAttempts": 0,\n  "MaximumEventAgeInSeconds": 0,\n  "DestinationConfig": {\n    "OnSuccess": "",\n    "OnFailure": ""\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  \"MaximumRetryAttempts\": 0,\n  \"MaximumEventAgeInSeconds\": 0,\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config")
  .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/2019-09-25/functions/:FunctionName/event-invoke-config',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  MaximumRetryAttempts: 0,
  MaximumEventAgeInSeconds: 0,
  DestinationConfig: {OnSuccess: '', OnFailure: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config',
  headers: {'content-type': 'application/json'},
  body: {
    MaximumRetryAttempts: 0,
    MaximumEventAgeInSeconds: 0,
    DestinationConfig: {OnSuccess: '', OnFailure: ''}
  },
  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}}/2019-09-25/functions/:FunctionName/event-invoke-config');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  MaximumRetryAttempts: 0,
  MaximumEventAgeInSeconds: 0,
  DestinationConfig: {
    OnSuccess: '',
    OnFailure: ''
  }
});

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}}/2019-09-25/functions/:FunctionName/event-invoke-config',
  headers: {'content-type': 'application/json'},
  data: {
    MaximumRetryAttempts: 0,
    MaximumEventAgeInSeconds: 0,
    DestinationConfig: {OnSuccess: '', OnFailure: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"MaximumRetryAttempts":0,"MaximumEventAgeInSeconds":0,"DestinationConfig":{"OnSuccess":"","OnFailure":""}}'
};

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 = @{ @"MaximumRetryAttempts": @0,
                              @"MaximumEventAgeInSeconds": @0,
                              @"DestinationConfig": @{ @"OnSuccess": @"", @"OnFailure": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config"]
                                                       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}}/2019-09-25/functions/:FunctionName/event-invoke-config" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"MaximumRetryAttempts\": 0,\n  \"MaximumEventAgeInSeconds\": 0,\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\n  }\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config",
  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([
    'MaximumRetryAttempts' => 0,
    'MaximumEventAgeInSeconds' => 0,
    'DestinationConfig' => [
        'OnSuccess' => '',
        'OnFailure' => ''
    ]
  ]),
  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}}/2019-09-25/functions/:FunctionName/event-invoke-config', [
  'body' => '{
  "MaximumRetryAttempts": 0,
  "MaximumEventAgeInSeconds": 0,
  "DestinationConfig": {
    "OnSuccess": "",
    "OnFailure": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config');
$request->setMethod(HTTP_METH_PUT);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'MaximumRetryAttempts' => 0,
  'MaximumEventAgeInSeconds' => 0,
  'DestinationConfig' => [
    'OnSuccess' => '',
    'OnFailure' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'MaximumRetryAttempts' => 0,
  'MaximumEventAgeInSeconds' => 0,
  'DestinationConfig' => [
    'OnSuccess' => '',
    'OnFailure' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config');
$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}}/2019-09-25/functions/:FunctionName/event-invoke-config' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "MaximumRetryAttempts": 0,
  "MaximumEventAgeInSeconds": 0,
  "DestinationConfig": {
    "OnSuccess": "",
    "OnFailure": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "MaximumRetryAttempts": 0,
  "MaximumEventAgeInSeconds": 0,
  "DestinationConfig": {
    "OnSuccess": "",
    "OnFailure": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"MaximumRetryAttempts\": 0,\n  \"MaximumEventAgeInSeconds\": 0,\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/2019-09-25/functions/:FunctionName/event-invoke-config", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config"

payload = {
    "MaximumRetryAttempts": 0,
    "MaximumEventAgeInSeconds": 0,
    "DestinationConfig": {
        "OnSuccess": "",
        "OnFailure": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config"

payload <- "{\n  \"MaximumRetryAttempts\": 0,\n  \"MaximumEventAgeInSeconds\": 0,\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\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}}/2019-09-25/functions/:FunctionName/event-invoke-config")

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  \"MaximumRetryAttempts\": 0,\n  \"MaximumEventAgeInSeconds\": 0,\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\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/2019-09-25/functions/:FunctionName/event-invoke-config') do |req|
  req.body = "{\n  \"MaximumRetryAttempts\": 0,\n  \"MaximumEventAgeInSeconds\": 0,\n  \"DestinationConfig\": {\n    \"OnSuccess\": \"\",\n    \"OnFailure\": \"\"\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}}/2019-09-25/functions/:FunctionName/event-invoke-config";

    let payload = json!({
        "MaximumRetryAttempts": 0,
        "MaximumEventAgeInSeconds": 0,
        "DestinationConfig": json!({
            "OnSuccess": "",
            "OnFailure": ""
        })
    });

    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 '{
  "MaximumRetryAttempts": 0,
  "MaximumEventAgeInSeconds": 0,
  "DestinationConfig": {
    "OnSuccess": "",
    "OnFailure": ""
  }
}' |  \
  http PUT {{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "MaximumRetryAttempts": 0,\n  "MaximumEventAgeInSeconds": 0,\n  "DestinationConfig": {\n    "OnSuccess": "",\n    "OnFailure": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "MaximumRetryAttempts": 0,
  "MaximumEventAgeInSeconds": 0,
  "DestinationConfig": [
    "OnSuccess": "",
    "OnFailure": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2019-09-25/functions/:FunctionName/event-invoke-config")! 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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier");

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  \"ProvisionedConcurrentExecutions\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier" {:query-params {:Qualifier ""}
                                                                                                                :content-type :json
                                                                                                                :form-params {:ProvisionedConcurrentExecutions 0}})

require "http/client"

url = "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ProvisionedConcurrentExecutions\": 0\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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier"),
    Content = new StringContent("{\n  \"ProvisionedConcurrentExecutions\": 0\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier");
var request = new RestRequest("", Method.Put);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ProvisionedConcurrentExecutions\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier"

	payload := strings.NewReader("{\n  \"ProvisionedConcurrentExecutions\": 0\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/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier= HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 42

{
  "ProvisionedConcurrentExecutions": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ProvisionedConcurrentExecutions\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier"))
    .header("content-type", "application/json")
    .method("PUT", HttpRequest.BodyPublishers.ofString("{\n  \"ProvisionedConcurrentExecutions\": 0\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ProvisionedConcurrentExecutions\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier")
  .put(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier")
  .header("content-type", "application/json")
  .body("{\n  \"ProvisionedConcurrentExecutions\": 0\n}")
  .asString();

const data = JSON.stringify({
  ProvisionedConcurrentExecutions: 0
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('PUT', '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier',
  params: {Qualifier: ''},
  headers: {'content-type': 'application/json'},
  data: {ProvisionedConcurrentExecutions: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ProvisionedConcurrentExecutions":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier',
  method: 'PUT',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ProvisionedConcurrentExecutions": 0\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ProvisionedConcurrentExecutions\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier")
  .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/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=',
  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({ProvisionedConcurrentExecutions: 0}));
req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier',
  qs: {Qualifier: ''},
  headers: {'content-type': 'application/json'},
  body: {ProvisionedConcurrentExecutions: 0},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier');

req.query({
  Qualifier: ''
});

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ProvisionedConcurrentExecutions: 0
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier',
  params: {Qualifier: ''},
  headers: {'content-type': 'application/json'},
  data: {ProvisionedConcurrentExecutions: 0}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier';
const options = {
  method: 'PUT',
  headers: {'content-type': 'application/json'},
  body: '{"ProvisionedConcurrentExecutions":0}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ProvisionedConcurrentExecutions": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier"]
                                                       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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ProvisionedConcurrentExecutions\": 0\n}" in

Client.call ~headers ~body `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier",
  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([
    'ProvisionedConcurrentExecutions' => 0
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier', [
  'body' => '{
  "ProvisionedConcurrentExecutions": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier');
$request->setMethod(HTTP_METH_PUT);

$request->setQueryData([
  'Qualifier' => ''
]);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ProvisionedConcurrentExecutions' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ProvisionedConcurrentExecutions' => 0
]));
$request->setRequestUrl('{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier');
$request->setRequestMethod('PUT');
$request->setBody($body);

$request->setQuery(new http\QueryString([
  'Qualifier' => ''
]));

$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}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ProvisionedConcurrentExecutions": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier' -Method PUT -Headers $headers -ContentType 'application/json' -Body '{
  "ProvisionedConcurrentExecutions": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ProvisionedConcurrentExecutions\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("PUT", "/baseUrl/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier"

querystring = {"Qualifier":""}

payload = { "ProvisionedConcurrentExecutions": 0 }
headers = {"content-type": "application/json"}

response = requests.put(url, json=payload, headers=headers, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier"

queryString <- list(Qualifier = "")

payload <- "{\n  \"ProvisionedConcurrentExecutions\": 0\n}"

encode <- "json"

response <- VERB("PUT", url, body = payload, query = queryString, content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier")

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  \"ProvisionedConcurrentExecutions\": 0\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.put('/baseUrl/2019-09-30/functions/:FunctionName/provisioned-concurrency') do |req|
  req.params['Qualifier'] = ''
  req.body = "{\n  \"ProvisionedConcurrentExecutions\": 0\n}"
end

puts response.status
puts response.body

use std::str::FromStr;
use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency#Qualifier";

    let querystring = [
        ("Qualifier", ""),
    ];

    let payload = json!({"ProvisionedConcurrentExecutions": 0});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .query(&querystring)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

echo '{
  "ProvisionedConcurrentExecutions": 0
}' |  \
  http PUT '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier' \
  content-type:application/json

wget --quiet \
  --method PUT \
  --header 'content-type: application/json' \
  --body-data '{\n  "ProvisionedConcurrentExecutions": 0\n}' \
  --output-document \
  - '{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier'

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["ProvisionedConcurrentExecutions": 0] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2019-09-30/functions/:FunctionName/provisioned-concurrency?Qualifier=#Qualifier")! 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}}/2021-07-20/functions/:FunctionName/runtime-management-config");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UpdateRuntimeOn\": \"\",\n  \"RuntimeVersionArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/2021-07-20/functions/:FunctionName/runtime-management-config" {:content-type :json
                                                                                                        :form-params {:UpdateRuntimeOn ""
                                                                                                                      :RuntimeVersionArn ""}})

require "http/client"

url = "{{baseUrl}}/2021-07-20/functions/:FunctionName/runtime-management-config"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"UpdateRuntimeOn\": \"\",\n  \"RuntimeVersionArn\": \"\"\n}"

response = HTTP::Client.put url, headers: headers, body: reqBody
puts response.body