Amazon Elasticsearch Service

PUT AcceptInboundCrossClusterSearchConnection

{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept

QUERY PARAMS

ConnectionId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept");

CURLcode ret = curl_easy_perform(hnd);

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

(client/put "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept")

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept"

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

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

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

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

}

PUT /baseUrl/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept"))
    .method("PUT", 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-01-01/es/ccs/inboundConnection/:ConnectionId/accept")
  .put(null)
  .build();

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

HttpResponse response = Unirest.put("{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept")
  .asString();

const data = null;

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

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

xhr.open('PUT', '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept'
};

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

const url = '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept';
const options = {method: 'PUT'};

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-01-01/es/ccs/inboundConnection/:ConnectionId/accept',
  method: 'PUT',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept")
  .put(null)
  .build()

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

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept');

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

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

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

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept'
};

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

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

const url = '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept';
const options = {method: 'PUT'};

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-01-01/es/ccs/inboundConnection/:ConnectionId/accept"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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-01-01/es/ccs/inboundConnection/:ConnectionId/accept" in

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

 "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

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

curl_close($curl);

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

request('PUT', '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept');
$request->setMethod(HTTP_METH_PUT);

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

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

setRequestUrl('{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept' -Method PUT

import http.client

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

conn.request("PUT", "/baseUrl/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept")

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

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

import requests

url = "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept")

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

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

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

require 'faraday'

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

response = conn.put('/baseUrl/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept') 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-01-01/es/ccs/inboundConnection/:ConnectionId/accept";

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

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

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept

http PUT {{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/accept")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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()

POST AddTags

{{baseUrl}}/2015-01-01/tags

BODY json

{
  "ARN": "",
  "TagList": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/tags");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/2015-01-01/tags" {:content-type :json
                                                            :form-params {:ARN ""
                                                                          :TagList [{:Key ""
                                                                                     :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/2015-01-01/tags"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ARN\": \"\",\n  \"TagList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/tags"

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

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

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

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

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

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

}

POST /baseUrl/2015-01-01/tags HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 82

{
  "ARN": "",
  "TagList": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/2015-01-01/tags")
  .header("content-type", "application/json")
  .body("{\n  \"ARN\": \"\",\n  \"TagList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

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

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/tags',
  headers: {'content-type': 'application/json'},
  data: {ARN: '', TagList: [{Key: '', Value: ''}]}
};

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

const url = '{{baseUrl}}/2015-01-01/tags';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ARN":"","TagList":[{"Key":"","Value":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/2015-01-01/tags',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ARN": "",\n  "TagList": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/tags',
  headers: {'content-type': 'application/json'},
  body: {ARN: '', TagList: [{Key: '', Value: ''}]},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/2015-01-01/tags');

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

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

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/tags',
  headers: {'content-type': 'application/json'},
  data: {ARN: '', TagList: [{Key: '', Value: ''}]}
};

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

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

const url = '{{baseUrl}}/2015-01-01/tags';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ARN":"","TagList":[{"Key":"","Value":""}]}'
};

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

#import 

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

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

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

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

 "{{baseUrl}}/2015-01-01/tags",
  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([
    'ARN' => '',
    'TagList' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/2015-01-01/tags', [
  'body' => '{
  "ARN": "",
  "TagList": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/tags');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

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

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/tags' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ARN": "",
  "TagList": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"ARN\": \"\",\n  \"TagList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/2015-01-01/tags", payload, headers)

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

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

import requests

url = "{{baseUrl}}/2015-01-01/tags"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/tags"

payload <- "{\n  \"ARN\": \"\",\n  \"TagList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/tags")

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

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

require 'faraday'

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

response = conn.post('/baseUrl/2015-01-01/tags') do |req|
  req.body = "{\n  \"ARN\": \"\",\n  \"TagList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "ARN": "",
        "TagList": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/2015-01-01/tags \
  --header 'content-type: application/json' \
  --data '{
  "ARN": "",
  "TagList": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

echo '{
  "ARN": "",
  "TagList": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/2015-01-01/tags \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ARN": "",\n  "TagList": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/2015-01-01/tags

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/tags")! 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()

POST AssociatePackage

{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName

QUERY PARAMS

PackageID

DomainName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName")

require "http/client"

url = "{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName"

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

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

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

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

}

POST /baseUrl/2015-01-01/packages/associate/:PackageID/:DomainName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName'
};

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

const url = '{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-01-01/packages/associate/:PackageID/:DomainName',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName'
};

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-01-01/packages/associate/:PackageID/:DomainName');

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-01-01/packages/associate/:PackageID/:DomainName'
};

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

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

const url = '{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName" in

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

 "{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/2015-01-01/packages/associate/:PackageID/:DomainName")

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

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

import requests

url = "{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/2015-01-01/packages/associate/:PackageID/:DomainName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName";

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName

http POST {{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/packages/associate/:PackageID/:DomainName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

POST AuthorizeVpcEndpointAccess

{{baseUrl}}/2015-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess

QUERY PARAMS

DomainName

BODY json

{
  "Account": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess");

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  \"Account\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/2015-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess" {:content-type :json
                                                                                                        :form-params {:Account ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess"

	payload := strings.NewReader("{\n  \"Account\": \"\"\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-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 19

{
  "Account": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Account\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/2015-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess")
  .header("content-type", "application/json")
  .body("{\n  \"Account\": \"\"\n}")
  .asString();

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

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-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess',
  headers: {'content-type': 'application/json'},
  data: {Account: ''}
};

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

const url = '{{baseUrl}}/2015-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Account":""}'
};

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-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Account": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Account\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess")
  .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-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess',
  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({Account: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess',
  headers: {'content-type': 'application/json'},
  body: {Account: ''},
  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-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess');

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

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

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-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess',
  headers: {'content-type': 'application/json'},
  data: {Account: ''}
};

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

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

const url = '{{baseUrl}}/2015-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Account":""}'
};

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess"]
                                                       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-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Account\": \"\"\n}" in

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

 "{{baseUrl}}/2015-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess",
  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([
    'Account' => ''
  ]),
  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-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess', [
  'body' => '{
  "Account": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'Account' => ''
]));
$request->setRequestUrl('{{baseUrl}}/2015-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess');
$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-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Account": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Account": ""
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/2015-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess", payload, headers)

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

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

import requests

url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess"

payload <- "{\n  \"Account\": \"\"\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-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess")

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  \"Account\": \"\"\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-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess') do |req|
  req.body = "{\n  \"Account\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess";

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

    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);
}

curl --request POST \
  --url {{baseUrl}}/2015-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess \
  --header 'content-type: application/json' \
  --data '{
  "Account": ""
}'

echo '{
  "Account": ""
}' |  \
  http POST {{baseUrl}}/2015-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Account": ""\n}' \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/domain/:DomainName/authorizeVpcEndpointAccess")! 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()

POST CancelElasticsearchServiceSoftwareUpdate

{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/cancel

BODY json

{
  "DomainName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/cancel");

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  \"DomainName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/cancel" {:content-type :json
                                                                                       :form-params {:DomainName ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/cancel"

	payload := strings.NewReader("{\n  \"DomainName\": \"\"\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-01-01/es/serviceSoftwareUpdate/cancel HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "DomainName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/cancel")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DomainName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.post("{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/cancel")
  .header("content-type", "application/json")
  .body("{\n  \"DomainName\": \"\"\n}")
  .asString();

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

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-01-01/es/serviceSoftwareUpdate/cancel');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/cancel',
  headers: {'content-type': 'application/json'},
  data: {DomainName: ''}
};

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

const url = '{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/cancel';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DomainName":""}'
};

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-01-01/es/serviceSoftwareUpdate/cancel',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DomainName": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DomainName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/cancel")
  .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-01-01/es/serviceSoftwareUpdate/cancel',
  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({DomainName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/cancel',
  headers: {'content-type': 'application/json'},
  body: {DomainName: ''},
  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-01-01/es/serviceSoftwareUpdate/cancel');

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

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

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-01-01/es/serviceSoftwareUpdate/cancel',
  headers: {'content-type': 'application/json'},
  data: {DomainName: ''}
};

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

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

const url = '{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/cancel';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DomainName":""}'
};

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/cancel"]
                                                       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-01-01/es/serviceSoftwareUpdate/cancel" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"DomainName\": \"\"\n}" in

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

 "{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/cancel",
  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([
    'DomainName' => ''
  ]),
  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-01-01/es/serviceSoftwareUpdate/cancel', [
  'body' => '{
  "DomainName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/cancel');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'DomainName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/cancel');
$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-01-01/es/serviceSoftwareUpdate/cancel' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DomainName": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/cancel' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DomainName": ""
}'

import http.client

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

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

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

conn.request("POST", "/baseUrl/2015-01-01/es/serviceSoftwareUpdate/cancel", payload, headers)

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

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

import requests

url = "{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/cancel"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/cancel"

payload <- "{\n  \"DomainName\": \"\"\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-01-01/es/serviceSoftwareUpdate/cancel")

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  \"DomainName\": \"\"\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-01-01/es/serviceSoftwareUpdate/cancel') do |req|
  req.body = "{\n  \"DomainName\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/cancel";

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

    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);
}

curl --request POST \
  --url {{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/cancel \
  --header 'content-type: application/json' \
  --data '{
  "DomainName": ""
}'

echo '{
  "DomainName": ""
}' |  \
  http POST {{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/cancel \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "DomainName": ""\n}' \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/cancel

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/cancel")! 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()

POST CreateElasticsearchDomain

{{baseUrl}}/2015-01-01/es/domain

BODY json

{
  "DomainName": "",
  "ElasticsearchVersion": "",
  "ElasticsearchClusterConfig": {
    "InstanceType": "",
    "InstanceCount": "",
    "DedicatedMasterEnabled": "",
    "ZoneAwarenessEnabled": "",
    "ZoneAwarenessConfig": "",
    "DedicatedMasterType": "",
    "DedicatedMasterCount": "",
    "WarmEnabled": "",
    "WarmType": "",
    "WarmCount": "",
    "ColdStorageOptions": ""
  },
  "EBSOptions": {
    "EBSEnabled": "",
    "VolumeType": "",
    "VolumeSize": "",
    "Iops": "",
    "Throughput": ""
  },
  "AccessPolicies": "",
  "SnapshotOptions": {
    "AutomatedSnapshotStartHour": ""
  },
  "VPCOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  },
  "CognitoOptions": {
    "Enabled": "",
    "UserPoolId": "",
    "IdentityPoolId": "",
    "RoleArn": ""
  },
  "EncryptionAtRestOptions": {
    "Enabled": "",
    "KmsKeyId": ""
  },
  "NodeToNodeEncryptionOptions": {
    "Enabled": ""
  },
  "AdvancedOptions": {},
  "LogPublishingOptions": {},
  "DomainEndpointOptions": {
    "EnforceHTTPS": "",
    "TLSSecurityPolicy": "",
    "CustomEndpointEnabled": "",
    "CustomEndpoint": "",
    "CustomEndpointCertificateArn": ""
  },
  "AdvancedSecurityOptions": {
    "Enabled": "",
    "InternalUserDatabaseEnabled": "",
    "MasterUserOptions": "",
    "SAMLOptions": "",
    "AnonymousAuthEnabled": ""
  },
  "AutoTuneOptions": {
    "DesiredState": "",
    "MaintenanceSchedules": ""
  },
  "TagList": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/domain");

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  \"DomainName\": \"\",\n  \"ElasticsearchVersion\": \"\",\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"AccessPolicies\": \"\",\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"TagList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/2015-01-01/es/domain" {:content-type :json
                                                                 :form-params {:DomainName ""
                                                                               :ElasticsearchVersion ""
                                                                               :ElasticsearchClusterConfig {:InstanceType ""
                                                                                                            :InstanceCount ""
                                                                                                            :DedicatedMasterEnabled ""
                                                                                                            :ZoneAwarenessEnabled ""
                                                                                                            :ZoneAwarenessConfig ""
                                                                                                            :DedicatedMasterType ""
                                                                                                            :DedicatedMasterCount ""
                                                                                                            :WarmEnabled ""
                                                                                                            :WarmType ""
                                                                                                            :WarmCount ""
                                                                                                            :ColdStorageOptions ""}
                                                                               :EBSOptions {:EBSEnabled ""
                                                                                            :VolumeType ""
                                                                                            :VolumeSize ""
                                                                                            :Iops ""
                                                                                            :Throughput ""}
                                                                               :AccessPolicies ""
                                                                               :SnapshotOptions {:AutomatedSnapshotStartHour ""}
                                                                               :VPCOptions {:SubnetIds ""
                                                                                            :SecurityGroupIds ""}
                                                                               :CognitoOptions {:Enabled ""
                                                                                                :UserPoolId ""
                                                                                                :IdentityPoolId ""
                                                                                                :RoleArn ""}
                                                                               :EncryptionAtRestOptions {:Enabled ""
                                                                                                         :KmsKeyId ""}
                                                                               :NodeToNodeEncryptionOptions {:Enabled ""}
                                                                               :AdvancedOptions {}
                                                                               :LogPublishingOptions {}
                                                                               :DomainEndpointOptions {:EnforceHTTPS ""
                                                                                                       :TLSSecurityPolicy ""
                                                                                                       :CustomEndpointEnabled ""
                                                                                                       :CustomEndpoint ""
                                                                                                       :CustomEndpointCertificateArn ""}
                                                                               :AdvancedSecurityOptions {:Enabled ""
                                                                                                         :InternalUserDatabaseEnabled ""
                                                                                                         :MasterUserOptions ""
                                                                                                         :SAMLOptions ""
                                                                                                         :AnonymousAuthEnabled ""}
                                                                               :AutoTuneOptions {:DesiredState ""
                                                                                                 :MaintenanceSchedules ""}
                                                                               :TagList [{:Key ""
                                                                                          :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/domain"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"DomainName\": \"\",\n  \"ElasticsearchVersion\": \"\",\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"AccessPolicies\": \"\",\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"TagList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/2015-01-01/es/domain"),
    Content = new StringContent("{\n  \"DomainName\": \"\",\n  \"ElasticsearchVersion\": \"\",\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"AccessPolicies\": \"\",\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"TagList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2015-01-01/es/domain");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DomainName\": \"\",\n  \"ElasticsearchVersion\": \"\",\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"AccessPolicies\": \"\",\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"TagList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/es/domain"

	payload := strings.NewReader("{\n  \"DomainName\": \"\",\n  \"ElasticsearchVersion\": \"\",\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"AccessPolicies\": \"\",\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"TagList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")

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

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

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

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

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

}

POST /baseUrl/2015-01-01/es/domain HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1490

{
  "DomainName": "",
  "ElasticsearchVersion": "",
  "ElasticsearchClusterConfig": {
    "InstanceType": "",
    "InstanceCount": "",
    "DedicatedMasterEnabled": "",
    "ZoneAwarenessEnabled": "",
    "ZoneAwarenessConfig": "",
    "DedicatedMasterType": "",
    "DedicatedMasterCount": "",
    "WarmEnabled": "",
    "WarmType": "",
    "WarmCount": "",
    "ColdStorageOptions": ""
  },
  "EBSOptions": {
    "EBSEnabled": "",
    "VolumeType": "",
    "VolumeSize": "",
    "Iops": "",
    "Throughput": ""
  },
  "AccessPolicies": "",
  "SnapshotOptions": {
    "AutomatedSnapshotStartHour": ""
  },
  "VPCOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  },
  "CognitoOptions": {
    "Enabled": "",
    "UserPoolId": "",
    "IdentityPoolId": "",
    "RoleArn": ""
  },
  "EncryptionAtRestOptions": {
    "Enabled": "",
    "KmsKeyId": ""
  },
  "NodeToNodeEncryptionOptions": {
    "Enabled": ""
  },
  "AdvancedOptions": {},
  "LogPublishingOptions": {},
  "DomainEndpointOptions": {
    "EnforceHTTPS": "",
    "TLSSecurityPolicy": "",
    "CustomEndpointEnabled": "",
    "CustomEndpoint": "",
    "CustomEndpointCertificateArn": ""
  },
  "AdvancedSecurityOptions": {
    "Enabled": "",
    "InternalUserDatabaseEnabled": "",
    "MasterUserOptions": "",
    "SAMLOptions": "",
    "AnonymousAuthEnabled": ""
  },
  "AutoTuneOptions": {
    "DesiredState": "",
    "MaintenanceSchedules": ""
  },
  "TagList": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-01-01/es/domain")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DomainName\": \"\",\n  \"ElasticsearchVersion\": \"\",\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"AccessPolicies\": \"\",\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"TagList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/domain"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DomainName\": \"\",\n  \"ElasticsearchVersion\": \"\",\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"AccessPolicies\": \"\",\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"TagList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"DomainName\": \"\",\n  \"ElasticsearchVersion\": \"\",\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"AccessPolicies\": \"\",\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"TagList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/domain")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/2015-01-01/es/domain")
  .header("content-type", "application/json")
  .body("{\n  \"DomainName\": \"\",\n  \"ElasticsearchVersion\": \"\",\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"AccessPolicies\": \"\",\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"TagList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  DomainName: '',
  ElasticsearchVersion: '',
  ElasticsearchClusterConfig: {
    InstanceType: '',
    InstanceCount: '',
    DedicatedMasterEnabled: '',
    ZoneAwarenessEnabled: '',
    ZoneAwarenessConfig: '',
    DedicatedMasterType: '',
    DedicatedMasterCount: '',
    WarmEnabled: '',
    WarmType: '',
    WarmCount: '',
    ColdStorageOptions: ''
  },
  EBSOptions: {
    EBSEnabled: '',
    VolumeType: '',
    VolumeSize: '',
    Iops: '',
    Throughput: ''
  },
  AccessPolicies: '',
  SnapshotOptions: {
    AutomatedSnapshotStartHour: ''
  },
  VPCOptions: {
    SubnetIds: '',
    SecurityGroupIds: ''
  },
  CognitoOptions: {
    Enabled: '',
    UserPoolId: '',
    IdentityPoolId: '',
    RoleArn: ''
  },
  EncryptionAtRestOptions: {
    Enabled: '',
    KmsKeyId: ''
  },
  NodeToNodeEncryptionOptions: {
    Enabled: ''
  },
  AdvancedOptions: {},
  LogPublishingOptions: {},
  DomainEndpointOptions: {
    EnforceHTTPS: '',
    TLSSecurityPolicy: '',
    CustomEndpointEnabled: '',
    CustomEndpoint: '',
    CustomEndpointCertificateArn: ''
  },
  AdvancedSecurityOptions: {
    Enabled: '',
    InternalUserDatabaseEnabled: '',
    MasterUserOptions: '',
    SAMLOptions: '',
    AnonymousAuthEnabled: ''
  },
  AutoTuneOptions: {
    DesiredState: '',
    MaintenanceSchedules: ''
  },
  TagList: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/2015-01-01/es/domain');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/domain',
  headers: {'content-type': 'application/json'},
  data: {
    DomainName: '',
    ElasticsearchVersion: '',
    ElasticsearchClusterConfig: {
      InstanceType: '',
      InstanceCount: '',
      DedicatedMasterEnabled: '',
      ZoneAwarenessEnabled: '',
      ZoneAwarenessConfig: '',
      DedicatedMasterType: '',
      DedicatedMasterCount: '',
      WarmEnabled: '',
      WarmType: '',
      WarmCount: '',
      ColdStorageOptions: ''
    },
    EBSOptions: {EBSEnabled: '', VolumeType: '', VolumeSize: '', Iops: '', Throughput: ''},
    AccessPolicies: '',
    SnapshotOptions: {AutomatedSnapshotStartHour: ''},
    VPCOptions: {SubnetIds: '', SecurityGroupIds: ''},
    CognitoOptions: {Enabled: '', UserPoolId: '', IdentityPoolId: '', RoleArn: ''},
    EncryptionAtRestOptions: {Enabled: '', KmsKeyId: ''},
    NodeToNodeEncryptionOptions: {Enabled: ''},
    AdvancedOptions: {},
    LogPublishingOptions: {},
    DomainEndpointOptions: {
      EnforceHTTPS: '',
      TLSSecurityPolicy: '',
      CustomEndpointEnabled: '',
      CustomEndpoint: '',
      CustomEndpointCertificateArn: ''
    },
    AdvancedSecurityOptions: {
      Enabled: '',
      InternalUserDatabaseEnabled: '',
      MasterUserOptions: '',
      SAMLOptions: '',
      AnonymousAuthEnabled: ''
    },
    AutoTuneOptions: {DesiredState: '', MaintenanceSchedules: ''},
    TagList: [{Key: '', Value: ''}]
  }
};

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

const url = '{{baseUrl}}/2015-01-01/es/domain';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DomainName":"","ElasticsearchVersion":"","ElasticsearchClusterConfig":{"InstanceType":"","InstanceCount":"","DedicatedMasterEnabled":"","ZoneAwarenessEnabled":"","ZoneAwarenessConfig":"","DedicatedMasterType":"","DedicatedMasterCount":"","WarmEnabled":"","WarmType":"","WarmCount":"","ColdStorageOptions":""},"EBSOptions":{"EBSEnabled":"","VolumeType":"","VolumeSize":"","Iops":"","Throughput":""},"AccessPolicies":"","SnapshotOptions":{"AutomatedSnapshotStartHour":""},"VPCOptions":{"SubnetIds":"","SecurityGroupIds":""},"CognitoOptions":{"Enabled":"","UserPoolId":"","IdentityPoolId":"","RoleArn":""},"EncryptionAtRestOptions":{"Enabled":"","KmsKeyId":""},"NodeToNodeEncryptionOptions":{"Enabled":""},"AdvancedOptions":{},"LogPublishingOptions":{},"DomainEndpointOptions":{"EnforceHTTPS":"","TLSSecurityPolicy":"","CustomEndpointEnabled":"","CustomEndpoint":"","CustomEndpointCertificateArn":""},"AdvancedSecurityOptions":{"Enabled":"","InternalUserDatabaseEnabled":"","MasterUserOptions":"","SAMLOptions":"","AnonymousAuthEnabled":""},"AutoTuneOptions":{"DesiredState":"","MaintenanceSchedules":""},"TagList":[{"Key":"","Value":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/2015-01-01/es/domain',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DomainName": "",\n  "ElasticsearchVersion": "",\n  "ElasticsearchClusterConfig": {\n    "InstanceType": "",\n    "InstanceCount": "",\n    "DedicatedMasterEnabled": "",\n    "ZoneAwarenessEnabled": "",\n    "ZoneAwarenessConfig": "",\n    "DedicatedMasterType": "",\n    "DedicatedMasterCount": "",\n    "WarmEnabled": "",\n    "WarmType": "",\n    "WarmCount": "",\n    "ColdStorageOptions": ""\n  },\n  "EBSOptions": {\n    "EBSEnabled": "",\n    "VolumeType": "",\n    "VolumeSize": "",\n    "Iops": "",\n    "Throughput": ""\n  },\n  "AccessPolicies": "",\n  "SnapshotOptions": {\n    "AutomatedSnapshotStartHour": ""\n  },\n  "VPCOptions": {\n    "SubnetIds": "",\n    "SecurityGroupIds": ""\n  },\n  "CognitoOptions": {\n    "Enabled": "",\n    "UserPoolId": "",\n    "IdentityPoolId": "",\n    "RoleArn": ""\n  },\n  "EncryptionAtRestOptions": {\n    "Enabled": "",\n    "KmsKeyId": ""\n  },\n  "NodeToNodeEncryptionOptions": {\n    "Enabled": ""\n  },\n  "AdvancedOptions": {},\n  "LogPublishingOptions": {},\n  "DomainEndpointOptions": {\n    "EnforceHTTPS": "",\n    "TLSSecurityPolicy": "",\n    "CustomEndpointEnabled": "",\n    "CustomEndpoint": "",\n    "CustomEndpointCertificateArn": ""\n  },\n  "AdvancedSecurityOptions": {\n    "Enabled": "",\n    "InternalUserDatabaseEnabled": "",\n    "MasterUserOptions": "",\n    "SAMLOptions": "",\n    "AnonymousAuthEnabled": ""\n  },\n  "AutoTuneOptions": {\n    "DesiredState": "",\n    "MaintenanceSchedules": ""\n  },\n  "TagList": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DomainName\": \"\",\n  \"ElasticsearchVersion\": \"\",\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"AccessPolicies\": \"\",\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"TagList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/domain")
  .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-01-01/es/domain',
  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({
  DomainName: '',
  ElasticsearchVersion: '',
  ElasticsearchClusterConfig: {
    InstanceType: '',
    InstanceCount: '',
    DedicatedMasterEnabled: '',
    ZoneAwarenessEnabled: '',
    ZoneAwarenessConfig: '',
    DedicatedMasterType: '',
    DedicatedMasterCount: '',
    WarmEnabled: '',
    WarmType: '',
    WarmCount: '',
    ColdStorageOptions: ''
  },
  EBSOptions: {EBSEnabled: '', VolumeType: '', VolumeSize: '', Iops: '', Throughput: ''},
  AccessPolicies: '',
  SnapshotOptions: {AutomatedSnapshotStartHour: ''},
  VPCOptions: {SubnetIds: '', SecurityGroupIds: ''},
  CognitoOptions: {Enabled: '', UserPoolId: '', IdentityPoolId: '', RoleArn: ''},
  EncryptionAtRestOptions: {Enabled: '', KmsKeyId: ''},
  NodeToNodeEncryptionOptions: {Enabled: ''},
  AdvancedOptions: {},
  LogPublishingOptions: {},
  DomainEndpointOptions: {
    EnforceHTTPS: '',
    TLSSecurityPolicy: '',
    CustomEndpointEnabled: '',
    CustomEndpoint: '',
    CustomEndpointCertificateArn: ''
  },
  AdvancedSecurityOptions: {
    Enabled: '',
    InternalUserDatabaseEnabled: '',
    MasterUserOptions: '',
    SAMLOptions: '',
    AnonymousAuthEnabled: ''
  },
  AutoTuneOptions: {DesiredState: '', MaintenanceSchedules: ''},
  TagList: [{Key: '', Value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/domain',
  headers: {'content-type': 'application/json'},
  body: {
    DomainName: '',
    ElasticsearchVersion: '',
    ElasticsearchClusterConfig: {
      InstanceType: '',
      InstanceCount: '',
      DedicatedMasterEnabled: '',
      ZoneAwarenessEnabled: '',
      ZoneAwarenessConfig: '',
      DedicatedMasterType: '',
      DedicatedMasterCount: '',
      WarmEnabled: '',
      WarmType: '',
      WarmCount: '',
      ColdStorageOptions: ''
    },
    EBSOptions: {EBSEnabled: '', VolumeType: '', VolumeSize: '', Iops: '', Throughput: ''},
    AccessPolicies: '',
    SnapshotOptions: {AutomatedSnapshotStartHour: ''},
    VPCOptions: {SubnetIds: '', SecurityGroupIds: ''},
    CognitoOptions: {Enabled: '', UserPoolId: '', IdentityPoolId: '', RoleArn: ''},
    EncryptionAtRestOptions: {Enabled: '', KmsKeyId: ''},
    NodeToNodeEncryptionOptions: {Enabled: ''},
    AdvancedOptions: {},
    LogPublishingOptions: {},
    DomainEndpointOptions: {
      EnforceHTTPS: '',
      TLSSecurityPolicy: '',
      CustomEndpointEnabled: '',
      CustomEndpoint: '',
      CustomEndpointCertificateArn: ''
    },
    AdvancedSecurityOptions: {
      Enabled: '',
      InternalUserDatabaseEnabled: '',
      MasterUserOptions: '',
      SAMLOptions: '',
      AnonymousAuthEnabled: ''
    },
    AutoTuneOptions: {DesiredState: '', MaintenanceSchedules: ''},
    TagList: [{Key: '', Value: ''}]
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/2015-01-01/es/domain');

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

req.type('json');
req.send({
  DomainName: '',
  ElasticsearchVersion: '',
  ElasticsearchClusterConfig: {
    InstanceType: '',
    InstanceCount: '',
    DedicatedMasterEnabled: '',
    ZoneAwarenessEnabled: '',
    ZoneAwarenessConfig: '',
    DedicatedMasterType: '',
    DedicatedMasterCount: '',
    WarmEnabled: '',
    WarmType: '',
    WarmCount: '',
    ColdStorageOptions: ''
  },
  EBSOptions: {
    EBSEnabled: '',
    VolumeType: '',
    VolumeSize: '',
    Iops: '',
    Throughput: ''
  },
  AccessPolicies: '',
  SnapshotOptions: {
    AutomatedSnapshotStartHour: ''
  },
  VPCOptions: {
    SubnetIds: '',
    SecurityGroupIds: ''
  },
  CognitoOptions: {
    Enabled: '',
    UserPoolId: '',
    IdentityPoolId: '',
    RoleArn: ''
  },
  EncryptionAtRestOptions: {
    Enabled: '',
    KmsKeyId: ''
  },
  NodeToNodeEncryptionOptions: {
    Enabled: ''
  },
  AdvancedOptions: {},
  LogPublishingOptions: {},
  DomainEndpointOptions: {
    EnforceHTTPS: '',
    TLSSecurityPolicy: '',
    CustomEndpointEnabled: '',
    CustomEndpoint: '',
    CustomEndpointCertificateArn: ''
  },
  AdvancedSecurityOptions: {
    Enabled: '',
    InternalUserDatabaseEnabled: '',
    MasterUserOptions: '',
    SAMLOptions: '',
    AnonymousAuthEnabled: ''
  },
  AutoTuneOptions: {
    DesiredState: '',
    MaintenanceSchedules: ''
  },
  TagList: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/domain',
  headers: {'content-type': 'application/json'},
  data: {
    DomainName: '',
    ElasticsearchVersion: '',
    ElasticsearchClusterConfig: {
      InstanceType: '',
      InstanceCount: '',
      DedicatedMasterEnabled: '',
      ZoneAwarenessEnabled: '',
      ZoneAwarenessConfig: '',
      DedicatedMasterType: '',
      DedicatedMasterCount: '',
      WarmEnabled: '',
      WarmType: '',
      WarmCount: '',
      ColdStorageOptions: ''
    },
    EBSOptions: {EBSEnabled: '', VolumeType: '', VolumeSize: '', Iops: '', Throughput: ''},
    AccessPolicies: '',
    SnapshotOptions: {AutomatedSnapshotStartHour: ''},
    VPCOptions: {SubnetIds: '', SecurityGroupIds: ''},
    CognitoOptions: {Enabled: '', UserPoolId: '', IdentityPoolId: '', RoleArn: ''},
    EncryptionAtRestOptions: {Enabled: '', KmsKeyId: ''},
    NodeToNodeEncryptionOptions: {Enabled: ''},
    AdvancedOptions: {},
    LogPublishingOptions: {},
    DomainEndpointOptions: {
      EnforceHTTPS: '',
      TLSSecurityPolicy: '',
      CustomEndpointEnabled: '',
      CustomEndpoint: '',
      CustomEndpointCertificateArn: ''
    },
    AdvancedSecurityOptions: {
      Enabled: '',
      InternalUserDatabaseEnabled: '',
      MasterUserOptions: '',
      SAMLOptions: '',
      AnonymousAuthEnabled: ''
    },
    AutoTuneOptions: {DesiredState: '', MaintenanceSchedules: ''},
    TagList: [{Key: '', Value: ''}]
  }
};

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

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

const url = '{{baseUrl}}/2015-01-01/es/domain';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DomainName":"","ElasticsearchVersion":"","ElasticsearchClusterConfig":{"InstanceType":"","InstanceCount":"","DedicatedMasterEnabled":"","ZoneAwarenessEnabled":"","ZoneAwarenessConfig":"","DedicatedMasterType":"","DedicatedMasterCount":"","WarmEnabled":"","WarmType":"","WarmCount":"","ColdStorageOptions":""},"EBSOptions":{"EBSEnabled":"","VolumeType":"","VolumeSize":"","Iops":"","Throughput":""},"AccessPolicies":"","SnapshotOptions":{"AutomatedSnapshotStartHour":""},"VPCOptions":{"SubnetIds":"","SecurityGroupIds":""},"CognitoOptions":{"Enabled":"","UserPoolId":"","IdentityPoolId":"","RoleArn":""},"EncryptionAtRestOptions":{"Enabled":"","KmsKeyId":""},"NodeToNodeEncryptionOptions":{"Enabled":""},"AdvancedOptions":{},"LogPublishingOptions":{},"DomainEndpointOptions":{"EnforceHTTPS":"","TLSSecurityPolicy":"","CustomEndpointEnabled":"","CustomEndpoint":"","CustomEndpointCertificateArn":""},"AdvancedSecurityOptions":{"Enabled":"","InternalUserDatabaseEnabled":"","MasterUserOptions":"","SAMLOptions":"","AnonymousAuthEnabled":""},"AutoTuneOptions":{"DesiredState":"","MaintenanceSchedules":""},"TagList":[{"Key":"","Value":""}]}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"DomainName": @"",
                              @"ElasticsearchVersion": @"",
                              @"ElasticsearchClusterConfig": @{ @"InstanceType": @"", @"InstanceCount": @"", @"DedicatedMasterEnabled": @"", @"ZoneAwarenessEnabled": @"", @"ZoneAwarenessConfig": @"", @"DedicatedMasterType": @"", @"DedicatedMasterCount": @"", @"WarmEnabled": @"", @"WarmType": @"", @"WarmCount": @"", @"ColdStorageOptions": @"" },
                              @"EBSOptions": @{ @"EBSEnabled": @"", @"VolumeType": @"", @"VolumeSize": @"", @"Iops": @"", @"Throughput": @"" },
                              @"AccessPolicies": @"",
                              @"SnapshotOptions": @{ @"AutomatedSnapshotStartHour": @"" },
                              @"VPCOptions": @{ @"SubnetIds": @"", @"SecurityGroupIds": @"" },
                              @"CognitoOptions": @{ @"Enabled": @"", @"UserPoolId": @"", @"IdentityPoolId": @"", @"RoleArn": @"" },
                              @"EncryptionAtRestOptions": @{ @"Enabled": @"", @"KmsKeyId": @"" },
                              @"NodeToNodeEncryptionOptions": @{ @"Enabled": @"" },
                              @"AdvancedOptions": @{  },
                              @"LogPublishingOptions": @{  },
                              @"DomainEndpointOptions": @{ @"EnforceHTTPS": @"", @"TLSSecurityPolicy": @"", @"CustomEndpointEnabled": @"", @"CustomEndpoint": @"", @"CustomEndpointCertificateArn": @"" },
                              @"AdvancedSecurityOptions": @{ @"Enabled": @"", @"InternalUserDatabaseEnabled": @"", @"MasterUserOptions": @"", @"SAMLOptions": @"", @"AnonymousAuthEnabled": @"" },
                              @"AutoTuneOptions": @{ @"DesiredState": @"", @"MaintenanceSchedules": @"" },
                              @"TagList": @[ @{ @"Key": @"", @"Value": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-01-01/es/domain"]
                                                       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-01-01/es/domain" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"DomainName\": \"\",\n  \"ElasticsearchVersion\": \"\",\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"AccessPolicies\": \"\",\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"TagList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/2015-01-01/es/domain",
  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([
    'DomainName' => '',
    'ElasticsearchVersion' => '',
    'ElasticsearchClusterConfig' => [
        'InstanceType' => '',
        'InstanceCount' => '',
        'DedicatedMasterEnabled' => '',
        'ZoneAwarenessEnabled' => '',
        'ZoneAwarenessConfig' => '',
        'DedicatedMasterType' => '',
        'DedicatedMasterCount' => '',
        'WarmEnabled' => '',
        'WarmType' => '',
        'WarmCount' => '',
        'ColdStorageOptions' => ''
    ],
    'EBSOptions' => [
        'EBSEnabled' => '',
        'VolumeType' => '',
        'VolumeSize' => '',
        'Iops' => '',
        'Throughput' => ''
    ],
    'AccessPolicies' => '',
    'SnapshotOptions' => [
        'AutomatedSnapshotStartHour' => ''
    ],
    'VPCOptions' => [
        'SubnetIds' => '',
        'SecurityGroupIds' => ''
    ],
    'CognitoOptions' => [
        'Enabled' => '',
        'UserPoolId' => '',
        'IdentityPoolId' => '',
        'RoleArn' => ''
    ],
    'EncryptionAtRestOptions' => [
        'Enabled' => '',
        'KmsKeyId' => ''
    ],
    'NodeToNodeEncryptionOptions' => [
        'Enabled' => ''
    ],
    'AdvancedOptions' => [
        
    ],
    'LogPublishingOptions' => [
        
    ],
    'DomainEndpointOptions' => [
        'EnforceHTTPS' => '',
        'TLSSecurityPolicy' => '',
        'CustomEndpointEnabled' => '',
        'CustomEndpoint' => '',
        'CustomEndpointCertificateArn' => ''
    ],
    'AdvancedSecurityOptions' => [
        'Enabled' => '',
        'InternalUserDatabaseEnabled' => '',
        'MasterUserOptions' => '',
        'SAMLOptions' => '',
        'AnonymousAuthEnabled' => ''
    ],
    'AutoTuneOptions' => [
        'DesiredState' => '',
        'MaintenanceSchedules' => ''
    ],
    'TagList' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/2015-01-01/es/domain', [
  'body' => '{
  "DomainName": "",
  "ElasticsearchVersion": "",
  "ElasticsearchClusterConfig": {
    "InstanceType": "",
    "InstanceCount": "",
    "DedicatedMasterEnabled": "",
    "ZoneAwarenessEnabled": "",
    "ZoneAwarenessConfig": "",
    "DedicatedMasterType": "",
    "DedicatedMasterCount": "",
    "WarmEnabled": "",
    "WarmType": "",
    "WarmCount": "",
    "ColdStorageOptions": ""
  },
  "EBSOptions": {
    "EBSEnabled": "",
    "VolumeType": "",
    "VolumeSize": "",
    "Iops": "",
    "Throughput": ""
  },
  "AccessPolicies": "",
  "SnapshotOptions": {
    "AutomatedSnapshotStartHour": ""
  },
  "VPCOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  },
  "CognitoOptions": {
    "Enabled": "",
    "UserPoolId": "",
    "IdentityPoolId": "",
    "RoleArn": ""
  },
  "EncryptionAtRestOptions": {
    "Enabled": "",
    "KmsKeyId": ""
  },
  "NodeToNodeEncryptionOptions": {
    "Enabled": ""
  },
  "AdvancedOptions": {},
  "LogPublishingOptions": {},
  "DomainEndpointOptions": {
    "EnforceHTTPS": "",
    "TLSSecurityPolicy": "",
    "CustomEndpointEnabled": "",
    "CustomEndpoint": "",
    "CustomEndpointCertificateArn": ""
  },
  "AdvancedSecurityOptions": {
    "Enabled": "",
    "InternalUserDatabaseEnabled": "",
    "MasterUserOptions": "",
    "SAMLOptions": "",
    "AnonymousAuthEnabled": ""
  },
  "AutoTuneOptions": {
    "DesiredState": "",
    "MaintenanceSchedules": ""
  },
  "TagList": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/domain');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DomainName' => '',
  'ElasticsearchVersion' => '',
  'ElasticsearchClusterConfig' => [
    'InstanceType' => '',
    'InstanceCount' => '',
    'DedicatedMasterEnabled' => '',
    'ZoneAwarenessEnabled' => '',
    'ZoneAwarenessConfig' => '',
    'DedicatedMasterType' => '',
    'DedicatedMasterCount' => '',
    'WarmEnabled' => '',
    'WarmType' => '',
    'WarmCount' => '',
    'ColdStorageOptions' => ''
  ],
  'EBSOptions' => [
    'EBSEnabled' => '',
    'VolumeType' => '',
    'VolumeSize' => '',
    'Iops' => '',
    'Throughput' => ''
  ],
  'AccessPolicies' => '',
  'SnapshotOptions' => [
    'AutomatedSnapshotStartHour' => ''
  ],
  'VPCOptions' => [
    'SubnetIds' => '',
    'SecurityGroupIds' => ''
  ],
  'CognitoOptions' => [
    'Enabled' => '',
    'UserPoolId' => '',
    'IdentityPoolId' => '',
    'RoleArn' => ''
  ],
  'EncryptionAtRestOptions' => [
    'Enabled' => '',
    'KmsKeyId' => ''
  ],
  'NodeToNodeEncryptionOptions' => [
    'Enabled' => ''
  ],
  'AdvancedOptions' => [
    
  ],
  'LogPublishingOptions' => [
    
  ],
  'DomainEndpointOptions' => [
    'EnforceHTTPS' => '',
    'TLSSecurityPolicy' => '',
    'CustomEndpointEnabled' => '',
    'CustomEndpoint' => '',
    'CustomEndpointCertificateArn' => ''
  ],
  'AdvancedSecurityOptions' => [
    'Enabled' => '',
    'InternalUserDatabaseEnabled' => '',
    'MasterUserOptions' => '',
    'SAMLOptions' => '',
    'AnonymousAuthEnabled' => ''
  ],
  'AutoTuneOptions' => [
    'DesiredState' => '',
    'MaintenanceSchedules' => ''
  ],
  'TagList' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'DomainName' => '',
  'ElasticsearchVersion' => '',
  'ElasticsearchClusterConfig' => [
    'InstanceType' => '',
    'InstanceCount' => '',
    'DedicatedMasterEnabled' => '',
    'ZoneAwarenessEnabled' => '',
    'ZoneAwarenessConfig' => '',
    'DedicatedMasterType' => '',
    'DedicatedMasterCount' => '',
    'WarmEnabled' => '',
    'WarmType' => '',
    'WarmCount' => '',
    'ColdStorageOptions' => ''
  ],
  'EBSOptions' => [
    'EBSEnabled' => '',
    'VolumeType' => '',
    'VolumeSize' => '',
    'Iops' => '',
    'Throughput' => ''
  ],
  'AccessPolicies' => '',
  'SnapshotOptions' => [
    'AutomatedSnapshotStartHour' => ''
  ],
  'VPCOptions' => [
    'SubnetIds' => '',
    'SecurityGroupIds' => ''
  ],
  'CognitoOptions' => [
    'Enabled' => '',
    'UserPoolId' => '',
    'IdentityPoolId' => '',
    'RoleArn' => ''
  ],
  'EncryptionAtRestOptions' => [
    'Enabled' => '',
    'KmsKeyId' => ''
  ],
  'NodeToNodeEncryptionOptions' => [
    'Enabled' => ''
  ],
  'AdvancedOptions' => [
    
  ],
  'LogPublishingOptions' => [
    
  ],
  'DomainEndpointOptions' => [
    'EnforceHTTPS' => '',
    'TLSSecurityPolicy' => '',
    'CustomEndpointEnabled' => '',
    'CustomEndpoint' => '',
    'CustomEndpointCertificateArn' => ''
  ],
  'AdvancedSecurityOptions' => [
    'Enabled' => '',
    'InternalUserDatabaseEnabled' => '',
    'MasterUserOptions' => '',
    'SAMLOptions' => '',
    'AnonymousAuthEnabled' => ''
  ],
  'AutoTuneOptions' => [
    'DesiredState' => '',
    'MaintenanceSchedules' => ''
  ],
  'TagList' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/2015-01-01/es/domain');
$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-01-01/es/domain' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DomainName": "",
  "ElasticsearchVersion": "",
  "ElasticsearchClusterConfig": {
    "InstanceType": "",
    "InstanceCount": "",
    "DedicatedMasterEnabled": "",
    "ZoneAwarenessEnabled": "",
    "ZoneAwarenessConfig": "",
    "DedicatedMasterType": "",
    "DedicatedMasterCount": "",
    "WarmEnabled": "",
    "WarmType": "",
    "WarmCount": "",
    "ColdStorageOptions": ""
  },
  "EBSOptions": {
    "EBSEnabled": "",
    "VolumeType": "",
    "VolumeSize": "",
    "Iops": "",
    "Throughput": ""
  },
  "AccessPolicies": "",
  "SnapshotOptions": {
    "AutomatedSnapshotStartHour": ""
  },
  "VPCOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  },
  "CognitoOptions": {
    "Enabled": "",
    "UserPoolId": "",
    "IdentityPoolId": "",
    "RoleArn": ""
  },
  "EncryptionAtRestOptions": {
    "Enabled": "",
    "KmsKeyId": ""
  },
  "NodeToNodeEncryptionOptions": {
    "Enabled": ""
  },
  "AdvancedOptions": {},
  "LogPublishingOptions": {},
  "DomainEndpointOptions": {
    "EnforceHTTPS": "",
    "TLSSecurityPolicy": "",
    "CustomEndpointEnabled": "",
    "CustomEndpoint": "",
    "CustomEndpointCertificateArn": ""
  },
  "AdvancedSecurityOptions": {
    "Enabled": "",
    "InternalUserDatabaseEnabled": "",
    "MasterUserOptions": "",
    "SAMLOptions": "",
    "AnonymousAuthEnabled": ""
  },
  "AutoTuneOptions": {
    "DesiredState": "",
    "MaintenanceSchedules": ""
  },
  "TagList": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/domain' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DomainName": "",
  "ElasticsearchVersion": "",
  "ElasticsearchClusterConfig": {
    "InstanceType": "",
    "InstanceCount": "",
    "DedicatedMasterEnabled": "",
    "ZoneAwarenessEnabled": "",
    "ZoneAwarenessConfig": "",
    "DedicatedMasterType": "",
    "DedicatedMasterCount": "",
    "WarmEnabled": "",
    "WarmType": "",
    "WarmCount": "",
    "ColdStorageOptions": ""
  },
  "EBSOptions": {
    "EBSEnabled": "",
    "VolumeType": "",
    "VolumeSize": "",
    "Iops": "",
    "Throughput": ""
  },
  "AccessPolicies": "",
  "SnapshotOptions": {
    "AutomatedSnapshotStartHour": ""
  },
  "VPCOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  },
  "CognitoOptions": {
    "Enabled": "",
    "UserPoolId": "",
    "IdentityPoolId": "",
    "RoleArn": ""
  },
  "EncryptionAtRestOptions": {
    "Enabled": "",
    "KmsKeyId": ""
  },
  "NodeToNodeEncryptionOptions": {
    "Enabled": ""
  },
  "AdvancedOptions": {},
  "LogPublishingOptions": {},
  "DomainEndpointOptions": {
    "EnforceHTTPS": "",
    "TLSSecurityPolicy": "",
    "CustomEndpointEnabled": "",
    "CustomEndpoint": "",
    "CustomEndpointCertificateArn": ""
  },
  "AdvancedSecurityOptions": {
    "Enabled": "",
    "InternalUserDatabaseEnabled": "",
    "MasterUserOptions": "",
    "SAMLOptions": "",
    "AnonymousAuthEnabled": ""
  },
  "AutoTuneOptions": {
    "DesiredState": "",
    "MaintenanceSchedules": ""
  },
  "TagList": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"DomainName\": \"\",\n  \"ElasticsearchVersion\": \"\",\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"AccessPolicies\": \"\",\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"TagList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

conn.request("POST", "/baseUrl/2015-01-01/es/domain", payload, headers)

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

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

import requests

url = "{{baseUrl}}/2015-01-01/es/domain"

payload = {
    "DomainName": "",
    "ElasticsearchVersion": "",
    "ElasticsearchClusterConfig": {
        "InstanceType": "",
        "InstanceCount": "",
        "DedicatedMasterEnabled": "",
        "ZoneAwarenessEnabled": "",
        "ZoneAwarenessConfig": "",
        "DedicatedMasterType": "",
        "DedicatedMasterCount": "",
        "WarmEnabled": "",
        "WarmType": "",
        "WarmCount": "",
        "ColdStorageOptions": ""
    },
    "EBSOptions": {
        "EBSEnabled": "",
        "VolumeType": "",
        "VolumeSize": "",
        "Iops": "",
        "Throughput": ""
    },
    "AccessPolicies": "",
    "SnapshotOptions": { "AutomatedSnapshotStartHour": "" },
    "VPCOptions": {
        "SubnetIds": "",
        "SecurityGroupIds": ""
    },
    "CognitoOptions": {
        "Enabled": "",
        "UserPoolId": "",
        "IdentityPoolId": "",
        "RoleArn": ""
    },
    "EncryptionAtRestOptions": {
        "Enabled": "",
        "KmsKeyId": ""
    },
    "NodeToNodeEncryptionOptions": { "Enabled": "" },
    "AdvancedOptions": {},
    "LogPublishingOptions": {},
    "DomainEndpointOptions": {
        "EnforceHTTPS": "",
        "TLSSecurityPolicy": "",
        "CustomEndpointEnabled": "",
        "CustomEndpoint": "",
        "CustomEndpointCertificateArn": ""
    },
    "AdvancedSecurityOptions": {
        "Enabled": "",
        "InternalUserDatabaseEnabled": "",
        "MasterUserOptions": "",
        "SAMLOptions": "",
        "AnonymousAuthEnabled": ""
    },
    "AutoTuneOptions": {
        "DesiredState": "",
        "MaintenanceSchedules": ""
    },
    "TagList": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/domain"

payload <- "{\n  \"DomainName\": \"\",\n  \"ElasticsearchVersion\": \"\",\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"AccessPolicies\": \"\",\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"TagList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/es/domain")

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  \"DomainName\": \"\",\n  \"ElasticsearchVersion\": \"\",\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"AccessPolicies\": \"\",\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"TagList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/2015-01-01/es/domain') do |req|
  req.body = "{\n  \"DomainName\": \"\",\n  \"ElasticsearchVersion\": \"\",\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"AccessPolicies\": \"\",\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"TagList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/domain";

    let payload = json!({
        "DomainName": "",
        "ElasticsearchVersion": "",
        "ElasticsearchClusterConfig": json!({
            "InstanceType": "",
            "InstanceCount": "",
            "DedicatedMasterEnabled": "",
            "ZoneAwarenessEnabled": "",
            "ZoneAwarenessConfig": "",
            "DedicatedMasterType": "",
            "DedicatedMasterCount": "",
            "WarmEnabled": "",
            "WarmType": "",
            "WarmCount": "",
            "ColdStorageOptions": ""
        }),
        "EBSOptions": json!({
            "EBSEnabled": "",
            "VolumeType": "",
            "VolumeSize": "",
            "Iops": "",
            "Throughput": ""
        }),
        "AccessPolicies": "",
        "SnapshotOptions": json!({"AutomatedSnapshotStartHour": ""}),
        "VPCOptions": json!({
            "SubnetIds": "",
            "SecurityGroupIds": ""
        }),
        "CognitoOptions": json!({
            "Enabled": "",
            "UserPoolId": "",
            "IdentityPoolId": "",
            "RoleArn": ""
        }),
        "EncryptionAtRestOptions": json!({
            "Enabled": "",
            "KmsKeyId": ""
        }),
        "NodeToNodeEncryptionOptions": json!({"Enabled": ""}),
        "AdvancedOptions": json!({}),
        "LogPublishingOptions": json!({}),
        "DomainEndpointOptions": json!({
            "EnforceHTTPS": "",
            "TLSSecurityPolicy": "",
            "CustomEndpointEnabled": "",
            "CustomEndpoint": "",
            "CustomEndpointCertificateArn": ""
        }),
        "AdvancedSecurityOptions": json!({
            "Enabled": "",
            "InternalUserDatabaseEnabled": "",
            "MasterUserOptions": "",
            "SAMLOptions": "",
            "AnonymousAuthEnabled": ""
        }),
        "AutoTuneOptions": json!({
            "DesiredState": "",
            "MaintenanceSchedules": ""
        }),
        "TagList": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/2015-01-01/es/domain \
  --header 'content-type: application/json' \
  --data '{
  "DomainName": "",
  "ElasticsearchVersion": "",
  "ElasticsearchClusterConfig": {
    "InstanceType": "",
    "InstanceCount": "",
    "DedicatedMasterEnabled": "",
    "ZoneAwarenessEnabled": "",
    "ZoneAwarenessConfig": "",
    "DedicatedMasterType": "",
    "DedicatedMasterCount": "",
    "WarmEnabled": "",
    "WarmType": "",
    "WarmCount": "",
    "ColdStorageOptions": ""
  },
  "EBSOptions": {
    "EBSEnabled": "",
    "VolumeType": "",
    "VolumeSize": "",
    "Iops": "",
    "Throughput": ""
  },
  "AccessPolicies": "",
  "SnapshotOptions": {
    "AutomatedSnapshotStartHour": ""
  },
  "VPCOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  },
  "CognitoOptions": {
    "Enabled": "",
    "UserPoolId": "",
    "IdentityPoolId": "",
    "RoleArn": ""
  },
  "EncryptionAtRestOptions": {
    "Enabled": "",
    "KmsKeyId": ""
  },
  "NodeToNodeEncryptionOptions": {
    "Enabled": ""
  },
  "AdvancedOptions": {},
  "LogPublishingOptions": {},
  "DomainEndpointOptions": {
    "EnforceHTTPS": "",
    "TLSSecurityPolicy": "",
    "CustomEndpointEnabled": "",
    "CustomEndpoint": "",
    "CustomEndpointCertificateArn": ""
  },
  "AdvancedSecurityOptions": {
    "Enabled": "",
    "InternalUserDatabaseEnabled": "",
    "MasterUserOptions": "",
    "SAMLOptions": "",
    "AnonymousAuthEnabled": ""
  },
  "AutoTuneOptions": {
    "DesiredState": "",
    "MaintenanceSchedules": ""
  },
  "TagList": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

echo '{
  "DomainName": "",
  "ElasticsearchVersion": "",
  "ElasticsearchClusterConfig": {
    "InstanceType": "",
    "InstanceCount": "",
    "DedicatedMasterEnabled": "",
    "ZoneAwarenessEnabled": "",
    "ZoneAwarenessConfig": "",
    "DedicatedMasterType": "",
    "DedicatedMasterCount": "",
    "WarmEnabled": "",
    "WarmType": "",
    "WarmCount": "",
    "ColdStorageOptions": ""
  },
  "EBSOptions": {
    "EBSEnabled": "",
    "VolumeType": "",
    "VolumeSize": "",
    "Iops": "",
    "Throughput": ""
  },
  "AccessPolicies": "",
  "SnapshotOptions": {
    "AutomatedSnapshotStartHour": ""
  },
  "VPCOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  },
  "CognitoOptions": {
    "Enabled": "",
    "UserPoolId": "",
    "IdentityPoolId": "",
    "RoleArn": ""
  },
  "EncryptionAtRestOptions": {
    "Enabled": "",
    "KmsKeyId": ""
  },
  "NodeToNodeEncryptionOptions": {
    "Enabled": ""
  },
  "AdvancedOptions": {},
  "LogPublishingOptions": {},
  "DomainEndpointOptions": {
    "EnforceHTTPS": "",
    "TLSSecurityPolicy": "",
    "CustomEndpointEnabled": "",
    "CustomEndpoint": "",
    "CustomEndpointCertificateArn": ""
  },
  "AdvancedSecurityOptions": {
    "Enabled": "",
    "InternalUserDatabaseEnabled": "",
    "MasterUserOptions": "",
    "SAMLOptions": "",
    "AnonymousAuthEnabled": ""
  },
  "AutoTuneOptions": {
    "DesiredState": "",
    "MaintenanceSchedules": ""
  },
  "TagList": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST {{baseUrl}}/2015-01-01/es/domain \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "DomainName": "",\n  "ElasticsearchVersion": "",\n  "ElasticsearchClusterConfig": {\n    "InstanceType": "",\n    "InstanceCount": "",\n    "DedicatedMasterEnabled": "",\n    "ZoneAwarenessEnabled": "",\n    "ZoneAwarenessConfig": "",\n    "DedicatedMasterType": "",\n    "DedicatedMasterCount": "",\n    "WarmEnabled": "",\n    "WarmType": "",\n    "WarmCount": "",\n    "ColdStorageOptions": ""\n  },\n  "EBSOptions": {\n    "EBSEnabled": "",\n    "VolumeType": "",\n    "VolumeSize": "",\n    "Iops": "",\n    "Throughput": ""\n  },\n  "AccessPolicies": "",\n  "SnapshotOptions": {\n    "AutomatedSnapshotStartHour": ""\n  },\n  "VPCOptions": {\n    "SubnetIds": "",\n    "SecurityGroupIds": ""\n  },\n  "CognitoOptions": {\n    "Enabled": "",\n    "UserPoolId": "",\n    "IdentityPoolId": "",\n    "RoleArn": ""\n  },\n  "EncryptionAtRestOptions": {\n    "Enabled": "",\n    "KmsKeyId": ""\n  },\n  "NodeToNodeEncryptionOptions": {\n    "Enabled": ""\n  },\n  "AdvancedOptions": {},\n  "LogPublishingOptions": {},\n  "DomainEndpointOptions": {\n    "EnforceHTTPS": "",\n    "TLSSecurityPolicy": "",\n    "CustomEndpointEnabled": "",\n    "CustomEndpoint": "",\n    "CustomEndpointCertificateArn": ""\n  },\n  "AdvancedSecurityOptions": {\n    "Enabled": "",\n    "InternalUserDatabaseEnabled": "",\n    "MasterUserOptions": "",\n    "SAMLOptions": "",\n    "AnonymousAuthEnabled": ""\n  },\n  "AutoTuneOptions": {\n    "DesiredState": "",\n    "MaintenanceSchedules": ""\n  },\n  "TagList": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/domain

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "DomainName": "",
  "ElasticsearchVersion": "",
  "ElasticsearchClusterConfig": [
    "InstanceType": "",
    "InstanceCount": "",
    "DedicatedMasterEnabled": "",
    "ZoneAwarenessEnabled": "",
    "ZoneAwarenessConfig": "",
    "DedicatedMasterType": "",
    "DedicatedMasterCount": "",
    "WarmEnabled": "",
    "WarmType": "",
    "WarmCount": "",
    "ColdStorageOptions": ""
  ],
  "EBSOptions": [
    "EBSEnabled": "",
    "VolumeType": "",
    "VolumeSize": "",
    "Iops": "",
    "Throughput": ""
  ],
  "AccessPolicies": "",
  "SnapshotOptions": ["AutomatedSnapshotStartHour": ""],
  "VPCOptions": [
    "SubnetIds": "",
    "SecurityGroupIds": ""
  ],
  "CognitoOptions": [
    "Enabled": "",
    "UserPoolId": "",
    "IdentityPoolId": "",
    "RoleArn": ""
  ],
  "EncryptionAtRestOptions": [
    "Enabled": "",
    "KmsKeyId": ""
  ],
  "NodeToNodeEncryptionOptions": ["Enabled": ""],
  "AdvancedOptions": [],
  "LogPublishingOptions": [],
  "DomainEndpointOptions": [
    "EnforceHTTPS": "",
    "TLSSecurityPolicy": "",
    "CustomEndpointEnabled": "",
    "CustomEndpoint": "",
    "CustomEndpointCertificateArn": ""
  ],
  "AdvancedSecurityOptions": [
    "Enabled": "",
    "InternalUserDatabaseEnabled": "",
    "MasterUserOptions": "",
    "SAMLOptions": "",
    "AnonymousAuthEnabled": ""
  ],
  "AutoTuneOptions": [
    "DesiredState": "",
    "MaintenanceSchedules": ""
  ],
  "TagList": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/domain")! 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()

POST CreateOutboundCrossClusterSearchConnection

{{baseUrl}}/2015-01-01/es/ccs/outboundConnection

BODY json

{
  "SourceDomainInfo": {
    "OwnerId": "",
    "DomainName": "",
    "Region": ""
  },
  "DestinationDomainInfo": {
    "OwnerId": "",
    "DomainName": "",
    "Region": ""
  },
  "ConnectionAlias": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection");

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  \"SourceDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"DestinationDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"ConnectionAlias\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection" {:content-type :json
                                                                                 :form-params {:SourceDomainInfo {:OwnerId ""
                                                                                                                  :DomainName ""
                                                                                                                  :Region ""}
                                                                                               :DestinationDomainInfo {:OwnerId ""
                                                                                                                       :DomainName ""
                                                                                                                       :Region ""}
                                                                                               :ConnectionAlias ""}})

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"SourceDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"DestinationDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"ConnectionAlias\": \"\"\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-01-01/es/ccs/outboundConnection"),
    Content = new StringContent("{\n  \"SourceDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"DestinationDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"ConnectionAlias\": \"\"\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-01-01/es/ccs/outboundConnection");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"SourceDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"DestinationDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"ConnectionAlias\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection"

	payload := strings.NewReader("{\n  \"SourceDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"DestinationDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"ConnectionAlias\": \"\"\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-01-01/es/ccs/outboundConnection HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 206

{
  "SourceDomainInfo": {
    "OwnerId": "",
    "DomainName": "",
    "Region": ""
  },
  "DestinationDomainInfo": {
    "OwnerId": "",
    "DomainName": "",
    "Region": ""
  },
  "ConnectionAlias": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"SourceDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"DestinationDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"ConnectionAlias\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/ccs/outboundConnection"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"SourceDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"DestinationDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"ConnectionAlias\": \"\"\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  \"SourceDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"DestinationDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"ConnectionAlias\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/ccs/outboundConnection")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/2015-01-01/es/ccs/outboundConnection")
  .header("content-type", "application/json")
  .body("{\n  \"SourceDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"DestinationDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"ConnectionAlias\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  SourceDomainInfo: {
    OwnerId: '',
    DomainName: '',
    Region: ''
  },
  DestinationDomainInfo: {
    OwnerId: '',
    DomainName: '',
    Region: ''
  },
  ConnectionAlias: ''
});

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-01-01/es/ccs/outboundConnection');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/ccs/outboundConnection',
  headers: {'content-type': 'application/json'},
  data: {
    SourceDomainInfo: {OwnerId: '', DomainName: '', Region: ''},
    DestinationDomainInfo: {OwnerId: '', DomainName: '', Region: ''},
    ConnectionAlias: ''
  }
};

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

const url = '{{baseUrl}}/2015-01-01/es/ccs/outboundConnection';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"SourceDomainInfo":{"OwnerId":"","DomainName":"","Region":""},"DestinationDomainInfo":{"OwnerId":"","DomainName":"","Region":""},"ConnectionAlias":""}'
};

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-01-01/es/ccs/outboundConnection',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SourceDomainInfo": {\n    "OwnerId": "",\n    "DomainName": "",\n    "Region": ""\n  },\n  "DestinationDomainInfo": {\n    "OwnerId": "",\n    "DomainName": "",\n    "Region": ""\n  },\n  "ConnectionAlias": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"SourceDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"DestinationDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"ConnectionAlias\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/ccs/outboundConnection")
  .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-01-01/es/ccs/outboundConnection',
  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({
  SourceDomainInfo: {OwnerId: '', DomainName: '', Region: ''},
  DestinationDomainInfo: {OwnerId: '', DomainName: '', Region: ''},
  ConnectionAlias: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/ccs/outboundConnection',
  headers: {'content-type': 'application/json'},
  body: {
    SourceDomainInfo: {OwnerId: '', DomainName: '', Region: ''},
    DestinationDomainInfo: {OwnerId: '', DomainName: '', Region: ''},
    ConnectionAlias: ''
  },
  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-01-01/es/ccs/outboundConnection');

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

req.type('json');
req.send({
  SourceDomainInfo: {
    OwnerId: '',
    DomainName: '',
    Region: ''
  },
  DestinationDomainInfo: {
    OwnerId: '',
    DomainName: '',
    Region: ''
  },
  ConnectionAlias: ''
});

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-01-01/es/ccs/outboundConnection',
  headers: {'content-type': 'application/json'},
  data: {
    SourceDomainInfo: {OwnerId: '', DomainName: '', Region: ''},
    DestinationDomainInfo: {OwnerId: '', DomainName: '', Region: ''},
    ConnectionAlias: ''
  }
};

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

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

const url = '{{baseUrl}}/2015-01-01/es/ccs/outboundConnection';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"SourceDomainInfo":{"OwnerId":"","DomainName":"","Region":""},"DestinationDomainInfo":{"OwnerId":"","DomainName":"","Region":""},"ConnectionAlias":""}'
};

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 = @{ @"SourceDomainInfo": @{ @"OwnerId": @"", @"DomainName": @"", @"Region": @"" },
                              @"DestinationDomainInfo": @{ @"OwnerId": @"", @"DomainName": @"", @"Region": @"" },
                              @"ConnectionAlias": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-01-01/es/ccs/outboundConnection"]
                                                       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-01-01/es/ccs/outboundConnection" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"SourceDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"DestinationDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"ConnectionAlias\": \"\"\n}" in

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

 "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection",
  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([
    'SourceDomainInfo' => [
        'OwnerId' => '',
        'DomainName' => '',
        'Region' => ''
    ],
    'DestinationDomainInfo' => [
        'OwnerId' => '',
        'DomainName' => '',
        'Region' => ''
    ],
    'ConnectionAlias' => ''
  ]),
  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-01-01/es/ccs/outboundConnection', [
  'body' => '{
  "SourceDomainInfo": {
    "OwnerId": "",
    "DomainName": "",
    "Region": ""
  },
  "DestinationDomainInfo": {
    "OwnerId": "",
    "DomainName": "",
    "Region": ""
  },
  "ConnectionAlias": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/ccs/outboundConnection');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'SourceDomainInfo' => [
    'OwnerId' => '',
    'DomainName' => '',
    'Region' => ''
  ],
  'DestinationDomainInfo' => [
    'OwnerId' => '',
    'DomainName' => '',
    'Region' => ''
  ],
  'ConnectionAlias' => ''
]));

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

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

append(json_encode([
  'SourceDomainInfo' => [
    'OwnerId' => '',
    'DomainName' => '',
    'Region' => ''
  ],
  'DestinationDomainInfo' => [
    'OwnerId' => '',
    'DomainName' => '',
    'Region' => ''
  ],
  'ConnectionAlias' => ''
]));
$request->setRequestUrl('{{baseUrl}}/2015-01-01/es/ccs/outboundConnection');
$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-01-01/es/ccs/outboundConnection' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SourceDomainInfo": {
    "OwnerId": "",
    "DomainName": "",
    "Region": ""
  },
  "DestinationDomainInfo": {
    "OwnerId": "",
    "DomainName": "",
    "Region": ""
  },
  "ConnectionAlias": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/ccs/outboundConnection' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SourceDomainInfo": {
    "OwnerId": "",
    "DomainName": "",
    "Region": ""
  },
  "DestinationDomainInfo": {
    "OwnerId": "",
    "DomainName": "",
    "Region": ""
  },
  "ConnectionAlias": ""
}'

import http.client

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

payload = "{\n  \"SourceDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"DestinationDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"ConnectionAlias\": \"\"\n}"

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

conn.request("POST", "/baseUrl/2015-01-01/es/ccs/outboundConnection", payload, headers)

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

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

import requests

url = "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection"

payload = {
    "SourceDomainInfo": {
        "OwnerId": "",
        "DomainName": "",
        "Region": ""
    },
    "DestinationDomainInfo": {
        "OwnerId": "",
        "DomainName": "",
        "Region": ""
    },
    "ConnectionAlias": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection"

payload <- "{\n  \"SourceDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"DestinationDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"ConnectionAlias\": \"\"\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-01-01/es/ccs/outboundConnection")

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  \"SourceDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"DestinationDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"ConnectionAlias\": \"\"\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-01-01/es/ccs/outboundConnection') do |req|
  req.body = "{\n  \"SourceDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"DestinationDomainInfo\": {\n    \"OwnerId\": \"\",\n    \"DomainName\": \"\",\n    \"Region\": \"\"\n  },\n  \"ConnectionAlias\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection";

    let payload = json!({
        "SourceDomainInfo": json!({
            "OwnerId": "",
            "DomainName": "",
            "Region": ""
        }),
        "DestinationDomainInfo": json!({
            "OwnerId": "",
            "DomainName": "",
            "Region": ""
        }),
        "ConnectionAlias": ""
    });

    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);
}

curl --request POST \
  --url {{baseUrl}}/2015-01-01/es/ccs/outboundConnection \
  --header 'content-type: application/json' \
  --data '{
  "SourceDomainInfo": {
    "OwnerId": "",
    "DomainName": "",
    "Region": ""
  },
  "DestinationDomainInfo": {
    "OwnerId": "",
    "DomainName": "",
    "Region": ""
  },
  "ConnectionAlias": ""
}'

echo '{
  "SourceDomainInfo": {
    "OwnerId": "",
    "DomainName": "",
    "Region": ""
  },
  "DestinationDomainInfo": {
    "OwnerId": "",
    "DomainName": "",
    "Region": ""
  },
  "ConnectionAlias": ""
}' |  \
  http POST {{baseUrl}}/2015-01-01/es/ccs/outboundConnection \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "SourceDomainInfo": {\n    "OwnerId": "",\n    "DomainName": "",\n    "Region": ""\n  },\n  "DestinationDomainInfo": {\n    "OwnerId": "",\n    "DomainName": "",\n    "Region": ""\n  },\n  "ConnectionAlias": ""\n}' \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/ccs/outboundConnection

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "SourceDomainInfo": [
    "OwnerId": "",
    "DomainName": "",
    "Region": ""
  ],
  "DestinationDomainInfo": [
    "OwnerId": "",
    "DomainName": "",
    "Region": ""
  ],
  "ConnectionAlias": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection")! 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()

POST CreatePackage

{{baseUrl}}/2015-01-01/packages

BODY json

{
  "PackageName": "",
  "PackageType": "",
  "PackageDescription": "",
  "PackageSource": {
    "S3BucketName": "",
    "S3Key": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/packages");

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  \"PackageName\": \"\",\n  \"PackageType\": \"\",\n  \"PackageDescription\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/2015-01-01/packages" {:content-type :json
                                                                :form-params {:PackageName ""
                                                                              :PackageType ""
                                                                              :PackageDescription ""
                                                                              :PackageSource {:S3BucketName ""
                                                                                              :S3Key ""}}})

require "http/client"

url = "{{baseUrl}}/2015-01-01/packages"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"PackageName\": \"\",\n  \"PackageType\": \"\",\n  \"PackageDescription\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\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-01-01/packages"),
    Content = new StringContent("{\n  \"PackageName\": \"\",\n  \"PackageType\": \"\",\n  \"PackageDescription\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\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-01-01/packages");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"PackageName\": \"\",\n  \"PackageType\": \"\",\n  \"PackageDescription\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/packages"

	payload := strings.NewReader("{\n  \"PackageName\": \"\",\n  \"PackageType\": \"\",\n  \"PackageDescription\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\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-01-01/packages HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 138

{
  "PackageName": "",
  "PackageType": "",
  "PackageDescription": "",
  "PackageSource": {
    "S3BucketName": "",
    "S3Key": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-01-01/packages")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"PackageName\": \"\",\n  \"PackageType\": \"\",\n  \"PackageDescription\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/packages"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"PackageName\": \"\",\n  \"PackageType\": \"\",\n  \"PackageDescription\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\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  \"PackageName\": \"\",\n  \"PackageType\": \"\",\n  \"PackageDescription\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-01-01/packages")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/2015-01-01/packages")
  .header("content-type", "application/json")
  .body("{\n  \"PackageName\": \"\",\n  \"PackageType\": \"\",\n  \"PackageDescription\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  PackageName: '',
  PackageType: '',
  PackageDescription: '',
  PackageSource: {
    S3BucketName: '',
    S3Key: ''
  }
});

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-01-01/packages');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/packages',
  headers: {'content-type': 'application/json'},
  data: {
    PackageName: '',
    PackageType: '',
    PackageDescription: '',
    PackageSource: {S3BucketName: '', S3Key: ''}
  }
};

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

const url = '{{baseUrl}}/2015-01-01/packages';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"PackageName":"","PackageType":"","PackageDescription":"","PackageSource":{"S3BucketName":"","S3Key":""}}'
};

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-01-01/packages',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "PackageName": "",\n  "PackageType": "",\n  "PackageDescription": "",\n  "PackageSource": {\n    "S3BucketName": "",\n    "S3Key": ""\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  \"PackageName\": \"\",\n  \"PackageType\": \"\",\n  \"PackageDescription\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/packages")
  .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-01-01/packages',
  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({
  PackageName: '',
  PackageType: '',
  PackageDescription: '',
  PackageSource: {S3BucketName: '', S3Key: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/packages',
  headers: {'content-type': 'application/json'},
  body: {
    PackageName: '',
    PackageType: '',
    PackageDescription: '',
    PackageSource: {S3BucketName: '', S3Key: ''}
  },
  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-01-01/packages');

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

req.type('json');
req.send({
  PackageName: '',
  PackageType: '',
  PackageDescription: '',
  PackageSource: {
    S3BucketName: '',
    S3Key: ''
  }
});

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-01-01/packages',
  headers: {'content-type': 'application/json'},
  data: {
    PackageName: '',
    PackageType: '',
    PackageDescription: '',
    PackageSource: {S3BucketName: '', S3Key: ''}
  }
};

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

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

const url = '{{baseUrl}}/2015-01-01/packages';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"PackageName":"","PackageType":"","PackageDescription":"","PackageSource":{"S3BucketName":"","S3Key":""}}'
};

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 = @{ @"PackageName": @"",
                              @"PackageType": @"",
                              @"PackageDescription": @"",
                              @"PackageSource": @{ @"S3BucketName": @"", @"S3Key": @"" } };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-01-01/packages"]
                                                       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-01-01/packages" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"PackageName\": \"\",\n  \"PackageType\": \"\",\n  \"PackageDescription\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\n  }\n}" in

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

 "{{baseUrl}}/2015-01-01/packages",
  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([
    'PackageName' => '',
    'PackageType' => '',
    'PackageDescription' => '',
    'PackageSource' => [
        'S3BucketName' => '',
        'S3Key' => ''
    ]
  ]),
  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-01-01/packages', [
  'body' => '{
  "PackageName": "",
  "PackageType": "",
  "PackageDescription": "",
  "PackageSource": {
    "S3BucketName": "",
    "S3Key": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/packages');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'PackageName' => '',
  'PackageType' => '',
  'PackageDescription' => '',
  'PackageSource' => [
    'S3BucketName' => '',
    'S3Key' => ''
  ]
]));

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

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

append(json_encode([
  'PackageName' => '',
  'PackageType' => '',
  'PackageDescription' => '',
  'PackageSource' => [
    'S3BucketName' => '',
    'S3Key' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/2015-01-01/packages');
$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-01-01/packages' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PackageName": "",
  "PackageType": "",
  "PackageDescription": "",
  "PackageSource": {
    "S3BucketName": "",
    "S3Key": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/packages' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PackageName": "",
  "PackageType": "",
  "PackageDescription": "",
  "PackageSource": {
    "S3BucketName": "",
    "S3Key": ""
  }
}'

import http.client

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

payload = "{\n  \"PackageName\": \"\",\n  \"PackageType\": \"\",\n  \"PackageDescription\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\n  }\n}"

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

conn.request("POST", "/baseUrl/2015-01-01/packages", payload, headers)

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

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

import requests

url = "{{baseUrl}}/2015-01-01/packages"

payload = {
    "PackageName": "",
    "PackageType": "",
    "PackageDescription": "",
    "PackageSource": {
        "S3BucketName": "",
        "S3Key": ""
    }
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/packages"

payload <- "{\n  \"PackageName\": \"\",\n  \"PackageType\": \"\",\n  \"PackageDescription\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\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-01-01/packages")

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  \"PackageName\": \"\",\n  \"PackageType\": \"\",\n  \"PackageDescription\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\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-01-01/packages') do |req|
  req.body = "{\n  \"PackageName\": \"\",\n  \"PackageType\": \"\",\n  \"PackageDescription\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\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-01-01/packages";

    let payload = json!({
        "PackageName": "",
        "PackageType": "",
        "PackageDescription": "",
        "PackageSource": json!({
            "S3BucketName": "",
            "S3Key": ""
        })
    });

    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);
}

curl --request POST \
  --url {{baseUrl}}/2015-01-01/packages \
  --header 'content-type: application/json' \
  --data '{
  "PackageName": "",
  "PackageType": "",
  "PackageDescription": "",
  "PackageSource": {
    "S3BucketName": "",
    "S3Key": ""
  }
}'

echo '{
  "PackageName": "",
  "PackageType": "",
  "PackageDescription": "",
  "PackageSource": {
    "S3BucketName": "",
    "S3Key": ""
  }
}' |  \
  http POST {{baseUrl}}/2015-01-01/packages \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "PackageName": "",\n  "PackageType": "",\n  "PackageDescription": "",\n  "PackageSource": {\n    "S3BucketName": "",\n    "S3Key": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/2015-01-01/packages

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "PackageName": "",
  "PackageType": "",
  "PackageDescription": "",
  "PackageSource": [
    "S3BucketName": "",
    "S3Key": ""
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/packages")! 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()

POST CreateVpcEndpoint

{{baseUrl}}/2015-01-01/es/vpcEndpoints

BODY json

{
  "DomainArn": "",
  "VpcOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  },
  "ClientToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/vpcEndpoints");

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  \"DomainArn\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"ClientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/2015-01-01/es/vpcEndpoints" {:content-type :json
                                                                       :form-params {:DomainArn ""
                                                                                     :VpcOptions {:SubnetIds ""
                                                                                                  :SecurityGroupIds ""}
                                                                                     :ClientToken ""}})

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/vpcEndpoints"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"DomainArn\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"ClientToken\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/2015-01-01/es/vpcEndpoints"),
    Content = new StringContent("{\n  \"DomainArn\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"ClientToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2015-01-01/es/vpcEndpoints");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DomainArn\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"ClientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/es/vpcEndpoints"

	payload := strings.NewReader("{\n  \"DomainArn\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"ClientToken\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/2015-01-01/es/vpcEndpoints HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 113

{
  "DomainArn": "",
  "VpcOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  },
  "ClientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-01-01/es/vpcEndpoints")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DomainArn\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"ClientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/vpcEndpoints"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DomainArn\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"ClientToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"DomainArn\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"ClientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/vpcEndpoints")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/2015-01-01/es/vpcEndpoints")
  .header("content-type", "application/json")
  .body("{\n  \"DomainArn\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"ClientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  DomainArn: '',
  VpcOptions: {
    SubnetIds: '',
    SecurityGroupIds: ''
  },
  ClientToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/2015-01-01/es/vpcEndpoints');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/vpcEndpoints',
  headers: {'content-type': 'application/json'},
  data: {
    DomainArn: '',
    VpcOptions: {SubnetIds: '', SecurityGroupIds: ''},
    ClientToken: ''
  }
};

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

const url = '{{baseUrl}}/2015-01-01/es/vpcEndpoints';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DomainArn":"","VpcOptions":{"SubnetIds":"","SecurityGroupIds":""},"ClientToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/2015-01-01/es/vpcEndpoints',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DomainArn": "",\n  "VpcOptions": {\n    "SubnetIds": "",\n    "SecurityGroupIds": ""\n  },\n  "ClientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DomainArn\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"ClientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/vpcEndpoints")
  .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-01-01/es/vpcEndpoints',
  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({
  DomainArn: '',
  VpcOptions: {SubnetIds: '', SecurityGroupIds: ''},
  ClientToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/vpcEndpoints',
  headers: {'content-type': 'application/json'},
  body: {
    DomainArn: '',
    VpcOptions: {SubnetIds: '', SecurityGroupIds: ''},
    ClientToken: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/2015-01-01/es/vpcEndpoints');

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

req.type('json');
req.send({
  DomainArn: '',
  VpcOptions: {
    SubnetIds: '',
    SecurityGroupIds: ''
  },
  ClientToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/vpcEndpoints',
  headers: {'content-type': 'application/json'},
  data: {
    DomainArn: '',
    VpcOptions: {SubnetIds: '', SecurityGroupIds: ''},
    ClientToken: ''
  }
};

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

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

const url = '{{baseUrl}}/2015-01-01/es/vpcEndpoints';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DomainArn":"","VpcOptions":{"SubnetIds":"","SecurityGroupIds":""},"ClientToken":""}'
};

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

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"DomainArn": @"",
                              @"VpcOptions": @{ @"SubnetIds": @"", @"SecurityGroupIds": @"" },
                              @"ClientToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-01-01/es/vpcEndpoints"]
                                                       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-01-01/es/vpcEndpoints" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"DomainArn\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"ClientToken\": \"\"\n}" in

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

 "{{baseUrl}}/2015-01-01/es/vpcEndpoints",
  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([
    'DomainArn' => '',
    'VpcOptions' => [
        'SubnetIds' => '',
        'SecurityGroupIds' => ''
    ],
    'ClientToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/2015-01-01/es/vpcEndpoints', [
  'body' => '{
  "DomainArn": "",
  "VpcOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  },
  "ClientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/vpcEndpoints');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DomainArn' => '',
  'VpcOptions' => [
    'SubnetIds' => '',
    'SecurityGroupIds' => ''
  ],
  'ClientToken' => ''
]));

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

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

append(json_encode([
  'DomainArn' => '',
  'VpcOptions' => [
    'SubnetIds' => '',
    'SecurityGroupIds' => ''
  ],
  'ClientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/2015-01-01/es/vpcEndpoints');
$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-01-01/es/vpcEndpoints' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DomainArn": "",
  "VpcOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  },
  "ClientToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/vpcEndpoints' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DomainArn": "",
  "VpcOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  },
  "ClientToken": ""
}'

import http.client

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

payload = "{\n  \"DomainArn\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"ClientToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/2015-01-01/es/vpcEndpoints", payload, headers)

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

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

import requests

url = "{{baseUrl}}/2015-01-01/es/vpcEndpoints"

payload = {
    "DomainArn": "",
    "VpcOptions": {
        "SubnetIds": "",
        "SecurityGroupIds": ""
    },
    "ClientToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/vpcEndpoints"

payload <- "{\n  \"DomainArn\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"ClientToken\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/es/vpcEndpoints")

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  \"DomainArn\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"ClientToken\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/2015-01-01/es/vpcEndpoints') do |req|
  req.body = "{\n  \"DomainArn\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"ClientToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/vpcEndpoints";

    let payload = json!({
        "DomainArn": "",
        "VpcOptions": json!({
            "SubnetIds": "",
            "SecurityGroupIds": ""
        }),
        "ClientToken": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/2015-01-01/es/vpcEndpoints \
  --header 'content-type: application/json' \
  --data '{
  "DomainArn": "",
  "VpcOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  },
  "ClientToken": ""
}'

echo '{
  "DomainArn": "",
  "VpcOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  },
  "ClientToken": ""
}' |  \
  http POST {{baseUrl}}/2015-01-01/es/vpcEndpoints \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "DomainArn": "",\n  "VpcOptions": {\n    "SubnetIds": "",\n    "SecurityGroupIds": ""\n  },\n  "ClientToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/vpcEndpoints

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "DomainArn": "",
  "VpcOptions": [
    "SubnetIds": "",
    "SecurityGroupIds": ""
  ],
  "ClientToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/vpcEndpoints")! 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()

DELETE DeleteElasticsearchDomain

{{baseUrl}}/2015-01-01/es/domain/:DomainName

QUERY PARAMS

DomainName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/domain/:DomainName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/2015-01-01/es/domain/:DomainName")

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName"

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

var client = new RestClient("{{baseUrl}}/2015-01-01/es/domain/:DomainName");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/es/domain/:DomainName"

	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-01-01/es/domain/:DomainName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/2015-01-01/es/domain/:DomainName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/domain/:DomainName"))
    .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-01-01/es/domain/:DomainName")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/2015-01-01/es/domain/:DomainName")
  .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-01-01/es/domain/:DomainName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/2015-01-01/es/domain/:DomainName'
};

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

const url = '{{baseUrl}}/2015-01-01/es/domain/:DomainName';
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-01-01/es/domain/:DomainName',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/domain/:DomainName")
  .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-01-01/es/domain/:DomainName',
  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-01-01/es/domain/:DomainName'
};

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-01-01/es/domain/:DomainName');

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-01-01/es/domain/:DomainName'
};

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

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

const url = '{{baseUrl}}/2015-01-01/es/domain/:DomainName';
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-01-01/es/domain/:DomainName"]
                                                       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-01-01/es/domain/:DomainName" in

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

 "{{baseUrl}}/2015-01-01/es/domain/:DomainName",
  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-01-01/es/domain/:DomainName');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/domain/:DomainName');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/2015-01-01/es/domain/:DomainName');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/es/domain/:DomainName' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/domain/:DomainName' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/2015-01-01/es/domain/:DomainName")

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

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

import requests

url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/domain/:DomainName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/es/domain/:DomainName")

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-01-01/es/domain/:DomainName') 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-01-01/es/domain/:DomainName";

    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);
}

curl --request DELETE \
  --url {{baseUrl}}/2015-01-01/es/domain/:DomainName

http DELETE {{baseUrl}}/2015-01-01/es/domain/:DomainName

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/domain/:DomainName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/domain/:DomainName")! 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()

DELETE DeleteElasticsearchServiceRole

{{baseUrl}}/2015-01-01/es/role

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/role");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/2015-01-01/es/role")

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/role"

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

var client = new RestClient("{{baseUrl}}/2015-01-01/es/role");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/es/role"

	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-01-01/es/role HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/2015-01-01/es/role")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/role"))
    .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-01-01/es/role")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/2015-01-01/es/role")
  .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-01-01/es/role');

xhr.send(data);

import axios from 'axios';

const options = {method: 'DELETE', url: '{{baseUrl}}/2015-01-01/es/role'};

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

const url = '{{baseUrl}}/2015-01-01/es/role';
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-01-01/es/role',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/role")
  .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-01-01/es/role',
  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-01-01/es/role'};

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-01-01/es/role');

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-01-01/es/role'};

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

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

const url = '{{baseUrl}}/2015-01-01/es/role';
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-01-01/es/role"]
                                                       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-01-01/es/role" in

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

 "{{baseUrl}}/2015-01-01/es/role",
  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-01-01/es/role');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/role');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/2015-01-01/es/role');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/es/role' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/role' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/2015-01-01/es/role")

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

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

import requests

url = "{{baseUrl}}/2015-01-01/es/role"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/role"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/es/role")

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-01-01/es/role') 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-01-01/es/role";

    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);
}

curl --request DELETE \
  --url {{baseUrl}}/2015-01-01/es/role

http DELETE {{baseUrl}}/2015-01-01/es/role

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/role

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/role")! 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()

DELETE DeleteInboundCrossClusterSearchConnection

{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId

QUERY PARAMS

ConnectionId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId")

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId"

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

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

var client = new RestClient("{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId"

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

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

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

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

}

DELETE /baseUrl/2015-01-01/es/ccs/inboundConnection/:ConnectionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId'
};

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

const url = '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-01-01/es/ccs/inboundConnection/:ConnectionId',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId'
};

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

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

const url = '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId" in

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

 "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/2015-01-01/es/ccs/inboundConnection/:ConnectionId")

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

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

import requests

url = "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/2015-01-01/es/ccs/inboundConnection/:ConnectionId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId";

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId

http DELETE {{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

DELETE DeleteOutboundCrossClusterSearchConnection

{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId

QUERY PARAMS

ConnectionId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId")

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId"

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

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

var client = new RestClient("{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId"

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

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

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

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

}

DELETE /baseUrl/2015-01-01/es/ccs/outboundConnection/:ConnectionId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId"))
    .method("DELETE", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId")
  .asString();

const data = null;

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

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

xhr.open('DELETE', '{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId'
};

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

const url = '{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId';
const options = {method: 'DELETE'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId")
  .delete(null)
  .build()

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

const http = require('https');

const options = {
  method: 'DELETE',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-01-01/es/ccs/outboundConnection/:ConnectionId',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId'
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('DELETE', '{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId');

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

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

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

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId'
};

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

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

const url = '{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId';
const options = {method: 'DELETE'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"DELETE"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId" in

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

 "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "DELETE",
]);

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

curl_close($curl);

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

request('DELETE', '{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/2015-01-01/es/ccs/outboundConnection/:ConnectionId")

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

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

import requests

url = "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId")

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

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

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

require 'faraday'

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

response = conn.delete('/baseUrl/2015-01-01/es/ccs/outboundConnection/:ConnectionId') do |req|
end

puts response.status
puts response.body

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

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId";

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

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

    dbg!(results);
}

curl --request DELETE \
  --url {{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId

http DELETE {{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/:ConnectionId")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "DELETE"

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

dataTask.resume()

DELETE DeletePackage

{{baseUrl}}/2015-01-01/packages/:PackageID

QUERY PARAMS

PackageID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/packages/:PackageID");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/2015-01-01/packages/:PackageID")

require "http/client"

url = "{{baseUrl}}/2015-01-01/packages/:PackageID"

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

var client = new RestClient("{{baseUrl}}/2015-01-01/packages/:PackageID");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/packages/:PackageID"

	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-01-01/packages/:PackageID HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/2015-01-01/packages/:PackageID")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

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

HttpResponse response = Unirest.delete("{{baseUrl}}/2015-01-01/packages/:PackageID")
  .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-01-01/packages/:PackageID');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/2015-01-01/packages/:PackageID'
};

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

const url = '{{baseUrl}}/2015-01-01/packages/:PackageID';
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-01-01/packages/:PackageID',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/packages/:PackageID")
  .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-01-01/packages/:PackageID',
  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-01-01/packages/:PackageID'
};

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-01-01/packages/:PackageID');

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-01-01/packages/:PackageID'
};

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

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

const url = '{{baseUrl}}/2015-01-01/packages/:PackageID';
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-01-01/packages/:PackageID"]
                                                       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-01-01/packages/:PackageID" in

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

 "{{baseUrl}}/2015-01-01/packages/:PackageID",
  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-01-01/packages/:PackageID');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/packages/:PackageID');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/2015-01-01/packages/:PackageID');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/packages/:PackageID' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/packages/:PackageID' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/2015-01-01/packages/:PackageID")

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

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

import requests

url = "{{baseUrl}}/2015-01-01/packages/:PackageID"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/packages/:PackageID"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/packages/:PackageID")

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-01-01/packages/:PackageID') 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-01-01/packages/:PackageID";

    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);
}

curl --request DELETE \
  --url {{baseUrl}}/2015-01-01/packages/:PackageID

http DELETE {{baseUrl}}/2015-01-01/packages/:PackageID

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/2015-01-01/packages/:PackageID

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/packages/:PackageID")! 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()

DELETE DeleteVpcEndpoint

{{baseUrl}}/2015-01-01/es/vpcEndpoints/:VpcEndpointId

QUERY PARAMS

VpcEndpointId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "DELETE");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/vpcEndpoints/:VpcEndpointId");

CURLcode ret = curl_easy_perform(hnd);

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

(client/delete "{{baseUrl}}/2015-01-01/es/vpcEndpoints/:VpcEndpointId")

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/vpcEndpoints/:VpcEndpointId"

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

var client = new RestClient("{{baseUrl}}/2015-01-01/es/vpcEndpoints/:VpcEndpointId");
var request = new RestRequest("", Method.Delete);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/es/vpcEndpoints/:VpcEndpointId"

	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-01-01/es/vpcEndpoints/:VpcEndpointId HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("DELETE", "{{baseUrl}}/2015-01-01/es/vpcEndpoints/:VpcEndpointId")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/vpcEndpoints/:VpcEndpointId"))
    .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-01-01/es/vpcEndpoints/:VpcEndpointId")
  .delete(null)
  .build();

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

HttpResponse response = Unirest.delete("{{baseUrl}}/2015-01-01/es/vpcEndpoints/:VpcEndpointId")
  .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-01-01/es/vpcEndpoints/:VpcEndpointId');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'DELETE',
  url: '{{baseUrl}}/2015-01-01/es/vpcEndpoints/:VpcEndpointId'
};

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

const url = '{{baseUrl}}/2015-01-01/es/vpcEndpoints/:VpcEndpointId';
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-01-01/es/vpcEndpoints/:VpcEndpointId',
  method: 'DELETE',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/vpcEndpoints/:VpcEndpointId")
  .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-01-01/es/vpcEndpoints/:VpcEndpointId',
  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-01-01/es/vpcEndpoints/:VpcEndpointId'
};

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-01-01/es/vpcEndpoints/:VpcEndpointId');

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-01-01/es/vpcEndpoints/:VpcEndpointId'
};

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

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

const url = '{{baseUrl}}/2015-01-01/es/vpcEndpoints/:VpcEndpointId';
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-01-01/es/vpcEndpoints/:VpcEndpointId"]
                                                       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-01-01/es/vpcEndpoints/:VpcEndpointId" in

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

 "{{baseUrl}}/2015-01-01/es/vpcEndpoints/:VpcEndpointId",
  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-01-01/es/vpcEndpoints/:VpcEndpointId');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/vpcEndpoints/:VpcEndpointId');
$request->setMethod(HTTP_METH_DELETE);

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

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

setRequestUrl('{{baseUrl}}/2015-01-01/es/vpcEndpoints/:VpcEndpointId');
$request->setRequestMethod('DELETE');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/es/vpcEndpoints/:VpcEndpointId' -Method DELETE

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/vpcEndpoints/:VpcEndpointId' -Method DELETE

import http.client

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

conn.request("DELETE", "/baseUrl/2015-01-01/es/vpcEndpoints/:VpcEndpointId")

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

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

import requests

url = "{{baseUrl}}/2015-01-01/es/vpcEndpoints/:VpcEndpointId"

response = requests.delete(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/vpcEndpoints/:VpcEndpointId"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/es/vpcEndpoints/:VpcEndpointId")

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-01-01/es/vpcEndpoints/:VpcEndpointId') 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-01-01/es/vpcEndpoints/:VpcEndpointId";

    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);
}

curl --request DELETE \
  --url {{baseUrl}}/2015-01-01/es/vpcEndpoints/:VpcEndpointId

http DELETE {{baseUrl}}/2015-01-01/es/vpcEndpoints/:VpcEndpointId

wget --quiet \
  --method DELETE \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/vpcEndpoints/:VpcEndpointId

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/vpcEndpoints/:VpcEndpointId")! 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()

GET DescribeDomainAutoTunes

{{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes

QUERY PARAMS

DomainName

BODY json

{
  "MaxResults": 0,
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes");

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  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes" {:content-type :json
                                                                                      :form-params {:MaxResults 0
                                                                                                    :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Get,
    RequestUri = new Uri("{{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes"),
    Content = new StringContent("{\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\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-01-01/es/domain/:DomainName/autoTunes");
var request = new RestRequest("", Method.Get);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes"

	payload := strings.NewReader("{\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("GET", 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))

}

GET /baseUrl/2015-01-01/es/domain/:DomainName/autoTunes HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "MaxResults": 0,
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes"))
    .header("content-type", "application/json")
    .method("GET", HttpRequest.BodyPublishers.ofString("{\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\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  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes")
  .get()
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes")
  .header("content-type", "application/json")
  .body("{\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  MaxResults: 0,
  NextToken: ''
});

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-01-01/es/domain/:DomainName/autoTunes');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes',
  headers: {'content-type': 'application/json'},
  data: {MaxResults: 0, NextToken: ''}
};

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

const url = '{{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes';
const options = {
  method: 'GET',
  headers: {'content-type': 'application/json'},
  body: '{"MaxResults":0,"NextToken":""}'
};

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-01-01/es/domain/:DomainName/autoTunes',
  method: 'GET',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "MaxResults": 0,\n  "NextToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes")
  .get()
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-01-01/es/domain/:DomainName/autoTunes',
  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({MaxResults: 0, NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes',
  headers: {'content-type': 'application/json'},
  body: {MaxResults: 0, NextToken: ''},
  json: true
};

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-01-01/es/domain/:DomainName/autoTunes');

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

req.type('json');
req.send({
  MaxResults: 0,
  NextToken: ''
});

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-01-01/es/domain/:DomainName/autoTunes',
  headers: {'content-type': 'application/json'},
  data: {MaxResults: 0, NextToken: ''}
};

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

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

const url = '{{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes';
const options = {
  method: 'GET',
  headers: {'content-type': 'application/json'},
  body: '{"MaxResults":0,"NextToken":""}'
};

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 = @{ @"MaxResults": @0,
                              @"NextToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"GET"];
[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-01-01/es/domain/:DomainName/autoTunes" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}" in

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

 "{{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_POSTFIELDS => json_encode([
    'MaxResults' => 0,
    'NextToken' => ''
  ]),
  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('GET', '{{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes', [
  'body' => '{
  "MaxResults": 0,
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes');
$request->setMethod(HTTP_METH_GET);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'MaxResults' => 0,
  'NextToken' => ''
]));

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

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

append(json_encode([
  'MaxResults' => 0,
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes');
$request->setRequestMethod('GET');
$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-01-01/es/domain/:DomainName/autoTunes' -Method GET -Headers $headers -ContentType 'application/json' -Body '{
  "MaxResults": 0,
  "NextToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes' -Method GET -Headers $headers -ContentType 'application/json' -Body '{
  "MaxResults": 0,
  "NextToken": ""
}'

import http.client

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

payload = "{\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}"

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

conn.request("GET", "/baseUrl/2015-01-01/es/domain/:DomainName/autoTunes", payload, headers)

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

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

import requests

url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes"

payload = {
    "MaxResults": 0,
    "NextToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes"

payload <- "{\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes")

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

request = Net::HTTP::Get.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\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.get('/baseUrl/2015-01-01/es/domain/:DomainName/autoTunes') do |req|
  req.body = "{\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes";

    let payload = json!({
        "MaxResults": 0,
        "NextToken": ""
    });

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

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes \
  --header 'content-type: application/json' \
  --data '{
  "MaxResults": 0,
  "NextToken": ""
}'

echo '{
  "MaxResults": 0,
  "NextToken": ""
}' |  \
  http GET {{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes \
  content-type:application/json

wget --quiet \
  --method GET \
  --header 'content-type: application/json' \
  --body-data '{\n  "MaxResults": 0,\n  "NextToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "MaxResults": 0,
  "NextToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/domain/:DomainName/autoTunes")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
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()

GET DescribeDomainChangeProgress

{{baseUrl}}/2015-01-01/es/domain/:DomainName/progress

QUERY PARAMS

DomainName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/domain/:DomainName/progress");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2015-01-01/es/domain/:DomainName/progress")

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName/progress"

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

var client = new RestClient("{{baseUrl}}/2015-01-01/es/domain/:DomainName/progress");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/es/domain/:DomainName/progress"

	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-01-01/es/domain/:DomainName/progress HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-01-01/es/domain/:DomainName/progress")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/domain/:DomainName/progress"))
    .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-01-01/es/domain/:DomainName/progress")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2015-01-01/es/domain/:DomainName/progress")
  .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-01-01/es/domain/:DomainName/progress');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-01-01/es/domain/:DomainName/progress'
};

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

const url = '{{baseUrl}}/2015-01-01/es/domain/:DomainName/progress';
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-01-01/es/domain/:DomainName/progress',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/domain/:DomainName/progress")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-01-01/es/domain/:DomainName/progress',
  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-01-01/es/domain/:DomainName/progress'
};

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-01-01/es/domain/:DomainName/progress');

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-01-01/es/domain/:DomainName/progress'
};

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

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

const url = '{{baseUrl}}/2015-01-01/es/domain/:DomainName/progress';
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-01-01/es/domain/:DomainName/progress"]
                                                       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-01-01/es/domain/:DomainName/progress" in

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

 "{{baseUrl}}/2015-01-01/es/domain/:DomainName/progress",
  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-01-01/es/domain/:DomainName/progress');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/domain/:DomainName/progress');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/2015-01-01/es/domain/:DomainName/progress');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/es/domain/:DomainName/progress' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/domain/:DomainName/progress' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/2015-01-01/es/domain/:DomainName/progress")

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

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

import requests

url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName/progress"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/domain/:DomainName/progress"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/es/domain/:DomainName/progress")

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-01-01/es/domain/:DomainName/progress') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName/progress";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/2015-01-01/es/domain/:DomainName/progress

http GET {{baseUrl}}/2015-01-01/es/domain/:DomainName/progress

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/domain/:DomainName/progress

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/domain/:DomainName/progress")! 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()

GET DescribeElasticsearchDomain

{{baseUrl}}/2015-01-01/es/domain/:DomainName

QUERY PARAMS

DomainName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/domain/:DomainName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2015-01-01/es/domain/:DomainName")

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName"

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

var client = new RestClient("{{baseUrl}}/2015-01-01/es/domain/:DomainName");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/es/domain/:DomainName"

	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-01-01/es/domain/:DomainName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-01-01/es/domain/:DomainName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/domain/:DomainName"))
    .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-01-01/es/domain/:DomainName")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2015-01-01/es/domain/:DomainName")
  .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-01-01/es/domain/:DomainName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-01-01/es/domain/:DomainName'
};

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

const url = '{{baseUrl}}/2015-01-01/es/domain/:DomainName';
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-01-01/es/domain/:DomainName',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/domain/:DomainName")
  .get()
  .build()

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

const http = require('https');

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

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-01-01/es/domain/:DomainName');

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-01-01/es/domain/:DomainName'
};

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

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

const url = '{{baseUrl}}/2015-01-01/es/domain/:DomainName';
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-01-01/es/domain/:DomainName"]
                                                       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-01-01/es/domain/:DomainName" in

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

 "{{baseUrl}}/2015-01-01/es/domain/:DomainName",
  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-01-01/es/domain/:DomainName');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/domain/:DomainName');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/2015-01-01/es/domain/:DomainName');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/es/domain/:DomainName' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/domain/:DomainName' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/2015-01-01/es/domain/:DomainName")

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

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

import requests

url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/domain/:DomainName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/es/domain/:DomainName")

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-01-01/es/domain/:DomainName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/2015-01-01/es/domain/:DomainName

http GET {{baseUrl}}/2015-01-01/es/domain/:DomainName

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/domain/:DomainName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/domain/:DomainName")! 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()

GET DescribeElasticsearchDomainConfig

{{baseUrl}}/2015-01-01/es/domain/:DomainName/config

QUERY PARAMS

DomainName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/domain/:DomainName/config");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2015-01-01/es/domain/:DomainName/config")

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName/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}}/2015-01-01/es/domain/:DomainName/config"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2015-01-01/es/domain/:DomainName/config");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/es/domain/:DomainName/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/2015-01-01/es/domain/:DomainName/config HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-01-01/es/domain/:DomainName/config")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/domain/:DomainName/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}}/2015-01-01/es/domain/:DomainName/config")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2015-01-01/es/domain/:DomainName/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}}/2015-01-01/es/domain/:DomainName/config');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-01-01/es/domain/:DomainName/config'
};

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

const url = '{{baseUrl}}/2015-01-01/es/domain/:DomainName/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}}/2015-01-01/es/domain/:DomainName/config',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/domain/:DomainName/config")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-01-01/es/domain/:DomainName/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}}/2015-01-01/es/domain/:DomainName/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}}/2015-01-01/es/domain/:DomainName/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}}/2015-01-01/es/domain/:DomainName/config'
};

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

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

const url = '{{baseUrl}}/2015-01-01/es/domain/:DomainName/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}}/2015-01-01/es/domain/:DomainName/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}}/2015-01-01/es/domain/:DomainName/config" in

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

 "{{baseUrl}}/2015-01-01/es/domain/:DomainName/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}}/2015-01-01/es/domain/:DomainName/config');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/domain/:DomainName/config');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/2015-01-01/es/domain/:DomainName/config');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/es/domain/:DomainName/config' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/domain/:DomainName/config' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/2015-01-01/es/domain/:DomainName/config")

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

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

import requests

url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName/config"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/domain/:DomainName/config"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/es/domain/:DomainName/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/2015-01-01/es/domain/:DomainName/config') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName/config";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/2015-01-01/es/domain/:DomainName/config

http GET {{baseUrl}}/2015-01-01/es/domain/:DomainName/config

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/domain/:DomainName/config

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/domain/:DomainName/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()

POST DescribeElasticsearchDomains

{{baseUrl}}/2015-01-01/es/domain-info

BODY json

{
  "DomainNames": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/domain-info");

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  \"DomainNames\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/2015-01-01/es/domain-info" {:content-type :json
                                                                      :form-params {:DomainNames []}})

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/domain-info"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"DomainNames\": []\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-01-01/es/domain-info"),
    Content = new StringContent("{\n  \"DomainNames\": []\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-01-01/es/domain-info");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DomainNames\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/es/domain-info"

	payload := strings.NewReader("{\n  \"DomainNames\": []\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-01-01/es/domain-info HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 23

{
  "DomainNames": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-01-01/es/domain-info")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DomainNames\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/domain-info"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DomainNames\": []\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  \"DomainNames\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/domain-info")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/2015-01-01/es/domain-info")
  .header("content-type", "application/json")
  .body("{\n  \"DomainNames\": []\n}")
  .asString();

const data = JSON.stringify({
  DomainNames: []
});

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-01-01/es/domain-info');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/domain-info',
  headers: {'content-type': 'application/json'},
  data: {DomainNames: []}
};

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

const url = '{{baseUrl}}/2015-01-01/es/domain-info';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DomainNames":[]}'
};

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-01-01/es/domain-info',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DomainNames": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DomainNames\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/domain-info")
  .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-01-01/es/domain-info',
  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({DomainNames: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/domain-info',
  headers: {'content-type': 'application/json'},
  body: {DomainNames: []},
  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-01-01/es/domain-info');

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

req.type('json');
req.send({
  DomainNames: []
});

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-01-01/es/domain-info',
  headers: {'content-type': 'application/json'},
  data: {DomainNames: []}
};

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

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

const url = '{{baseUrl}}/2015-01-01/es/domain-info';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DomainNames":[]}'
};

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 = @{ @"DomainNames": @[  ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-01-01/es/domain-info"]
                                                       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-01-01/es/domain-info" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"DomainNames\": []\n}" in

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

 "{{baseUrl}}/2015-01-01/es/domain-info",
  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([
    'DomainNames' => [
        
    ]
  ]),
  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-01-01/es/domain-info', [
  'body' => '{
  "DomainNames": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/domain-info');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'DomainNames' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/2015-01-01/es/domain-info');
$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-01-01/es/domain-info' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DomainNames": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/domain-info' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DomainNames": []
}'

import http.client

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

payload = "{\n  \"DomainNames\": []\n}"

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

conn.request("POST", "/baseUrl/2015-01-01/es/domain-info", payload, headers)

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

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

import requests

url = "{{baseUrl}}/2015-01-01/es/domain-info"

payload = { "DomainNames": [] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/domain-info"

payload <- "{\n  \"DomainNames\": []\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-01-01/es/domain-info")

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  \"DomainNames\": []\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-01-01/es/domain-info') do |req|
  req.body = "{\n  \"DomainNames\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/domain-info";

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

    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);
}

curl --request POST \
  --url {{baseUrl}}/2015-01-01/es/domain-info \
  --header 'content-type: application/json' \
  --data '{
  "DomainNames": []
}'

echo '{
  "DomainNames": []
}' |  \
  http POST {{baseUrl}}/2015-01-01/es/domain-info \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "DomainNames": []\n}' \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/domain-info

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/domain-info")! 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()

GET DescribeElasticsearchInstanceTypeLimits

{{baseUrl}}/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType

QUERY PARAMS

InstanceType

ElasticsearchVersion

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType")

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType"

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

var client = new RestClient("{{baseUrl}}/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType"

	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-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType"))
    .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-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType")
  .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-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType'
};

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

const url = '{{baseUrl}}/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType';
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-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType")
  .get()
  .build()

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

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType',
  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-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType'
};

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-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType');

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-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType'
};

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

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

const url = '{{baseUrl}}/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType';
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-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType"]
                                                       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-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType" in

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

 "{{baseUrl}}/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType",
  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-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType")

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

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

import requests

url = "{{baseUrl}}/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType")

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-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType

http GET {{baseUrl}}/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/instanceTypeLimits/:ElasticsearchVersion/:InstanceType")! 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()

POST DescribeInboundCrossClusterSearchConnections

{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/search

BODY json

{
  "Filters": [
    {
      "Name": "",
      "Values": ""
    }
  ],
  "MaxResults": 0,
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/search");

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  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/search" {:content-type :json
                                                                                       :form-params {:Filters [{:Name ""
                                                                                                                :Values ""}]
                                                                                                     :MaxResults 0
                                                                                                     :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/search"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\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-01-01/es/ccs/inboundConnection/search"),
    Content = new StringContent("{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\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-01-01/es/ccs/inboundConnection/search");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/search"

	payload := strings.NewReader("{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\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-01-01/es/ccs/inboundConnection/search HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 109

{
  "Filters": [
    {
      "Name": "",
      "Values": ""
    }
  ],
  "MaxResults": 0,
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/search")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/search"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\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  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/search")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/search")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Filters: [
    {
      Name: '',
      Values: ''
    }
  ],
  MaxResults: 0,
  NextToken: ''
});

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-01-01/es/ccs/inboundConnection/search');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/search',
  headers: {'content-type': 'application/json'},
  data: {Filters: [{Name: '', Values: ''}], MaxResults: 0, NextToken: ''}
};

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

const url = '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/search';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Filters":[{"Name":"","Values":""}],"MaxResults":0,"NextToken":""}'
};

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-01-01/es/ccs/inboundConnection/search',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": [\n    {\n      "Name": "",\n      "Values": ""\n    }\n  ],\n  "MaxResults": 0,\n  "NextToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/search")
  .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-01-01/es/ccs/inboundConnection/search',
  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({Filters: [{Name: '', Values: ''}], MaxResults: 0, NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/search',
  headers: {'content-type': 'application/json'},
  body: {Filters: [{Name: '', Values: ''}], MaxResults: 0, NextToken: ''},
  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-01-01/es/ccs/inboundConnection/search');

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

req.type('json');
req.send({
  Filters: [
    {
      Name: '',
      Values: ''
    }
  ],
  MaxResults: 0,
  NextToken: ''
});

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-01-01/es/ccs/inboundConnection/search',
  headers: {'content-type': 'application/json'},
  data: {Filters: [{Name: '', Values: ''}], MaxResults: 0, NextToken: ''}
};

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

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

const url = '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/search';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Filters":[{"Name":"","Values":""}],"MaxResults":0,"NextToken":""}'
};

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 = @{ @"Filters": @[ @{ @"Name": @"", @"Values": @"" } ],
                              @"MaxResults": @0,
                              @"NextToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/search"]
                                                       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-01-01/es/ccs/inboundConnection/search" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}" in

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

 "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/search",
  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([
    'Filters' => [
        [
                'Name' => '',
                'Values' => ''
        ]
    ],
    'MaxResults' => 0,
    'NextToken' => ''
  ]),
  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-01-01/es/ccs/inboundConnection/search', [
  'body' => '{
  "Filters": [
    {
      "Name": "",
      "Values": ""
    }
  ],
  "MaxResults": 0,
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/search');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => [
    [
        'Name' => '',
        'Values' => ''
    ]
  ],
  'MaxResults' => 0,
  'NextToken' => ''
]));

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

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

append(json_encode([
  'Filters' => [
    [
        'Name' => '',
        'Values' => ''
    ]
  ],
  'MaxResults' => 0,
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/search');
$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-01-01/es/ccs/inboundConnection/search' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": [
    {
      "Name": "",
      "Values": ""
    }
  ],
  "MaxResults": 0,
  "NextToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/search' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": [
    {
      "Name": "",
      "Values": ""
    }
  ],
  "MaxResults": 0,
  "NextToken": ""
}'

import http.client

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

payload = "{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/2015-01-01/es/ccs/inboundConnection/search", payload, headers)

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

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

import requests

url = "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/search"

payload = {
    "Filters": [
        {
            "Name": "",
            "Values": ""
        }
    ],
    "MaxResults": 0,
    "NextToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/search"

payload <- "{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\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-01-01/es/ccs/inboundConnection/search")

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  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\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-01-01/es/ccs/inboundConnection/search') do |req|
  req.body = "{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/search";

    let payload = json!({
        "Filters": (
            json!({
                "Name": "",
                "Values": ""
            })
        ),
        "MaxResults": 0,
        "NextToken": ""
    });

    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);
}

curl --request POST \
  --url {{baseUrl}}/2015-01-01/es/ccs/inboundConnection/search \
  --header 'content-type: application/json' \
  --data '{
  "Filters": [
    {
      "Name": "",
      "Values": ""
    }
  ],
  "MaxResults": 0,
  "NextToken": ""
}'

echo '{
  "Filters": [
    {
      "Name": "",
      "Values": ""
    }
  ],
  "MaxResults": 0,
  "NextToken": ""
}' |  \
  http POST {{baseUrl}}/2015-01-01/es/ccs/inboundConnection/search \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": [\n    {\n      "Name": "",\n      "Values": ""\n    }\n  ],\n  "MaxResults": 0,\n  "NextToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/ccs/inboundConnection/search

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Filters": [
    [
      "Name": "",
      "Values": ""
    ]
  ],
  "MaxResults": 0,
  "NextToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/search")! 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()

POST DescribeOutboundCrossClusterSearchConnections

{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/search

BODY json

{
  "Filters": [
    {
      "Name": "",
      "Values": ""
    }
  ],
  "MaxResults": 0,
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/search");

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  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/search" {:content-type :json
                                                                                        :form-params {:Filters [{:Name ""
                                                                                                                 :Values ""}]
                                                                                                      :MaxResults 0
                                                                                                      :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/search"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\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-01-01/es/ccs/outboundConnection/search"),
    Content = new StringContent("{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\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-01-01/es/ccs/outboundConnection/search");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/search"

	payload := strings.NewReader("{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\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-01-01/es/ccs/outboundConnection/search HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 109

{
  "Filters": [
    {
      "Name": "",
      "Values": ""
    }
  ],
  "MaxResults": 0,
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/search")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/search"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\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  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/search")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/search")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Filters: [
    {
      Name: '',
      Values: ''
    }
  ],
  MaxResults: 0,
  NextToken: ''
});

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-01-01/es/ccs/outboundConnection/search');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/search',
  headers: {'content-type': 'application/json'},
  data: {Filters: [{Name: '', Values: ''}], MaxResults: 0, NextToken: ''}
};

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

const url = '{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/search';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Filters":[{"Name":"","Values":""}],"MaxResults":0,"NextToken":""}'
};

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-01-01/es/ccs/outboundConnection/search',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": [\n    {\n      "Name": "",\n      "Values": ""\n    }\n  ],\n  "MaxResults": 0,\n  "NextToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/search")
  .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-01-01/es/ccs/outboundConnection/search',
  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({Filters: [{Name: '', Values: ''}], MaxResults: 0, NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/search',
  headers: {'content-type': 'application/json'},
  body: {Filters: [{Name: '', Values: ''}], MaxResults: 0, NextToken: ''},
  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-01-01/es/ccs/outboundConnection/search');

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

req.type('json');
req.send({
  Filters: [
    {
      Name: '',
      Values: ''
    }
  ],
  MaxResults: 0,
  NextToken: ''
});

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-01-01/es/ccs/outboundConnection/search',
  headers: {'content-type': 'application/json'},
  data: {Filters: [{Name: '', Values: ''}], MaxResults: 0, NextToken: ''}
};

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

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

const url = '{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/search';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Filters":[{"Name":"","Values":""}],"MaxResults":0,"NextToken":""}'
};

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 = @{ @"Filters": @[ @{ @"Name": @"", @"Values": @"" } ],
                              @"MaxResults": @0,
                              @"NextToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/search"]
                                                       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-01-01/es/ccs/outboundConnection/search" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}" in

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

 "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/search",
  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([
    'Filters' => [
        [
                'Name' => '',
                'Values' => ''
        ]
    ],
    'MaxResults' => 0,
    'NextToken' => ''
  ]),
  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-01-01/es/ccs/outboundConnection/search', [
  'body' => '{
  "Filters": [
    {
      "Name": "",
      "Values": ""
    }
  ],
  "MaxResults": 0,
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/search');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => [
    [
        'Name' => '',
        'Values' => ''
    ]
  ],
  'MaxResults' => 0,
  'NextToken' => ''
]));

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

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

append(json_encode([
  'Filters' => [
    [
        'Name' => '',
        'Values' => ''
    ]
  ],
  'MaxResults' => 0,
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/search');
$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-01-01/es/ccs/outboundConnection/search' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": [
    {
      "Name": "",
      "Values": ""
    }
  ],
  "MaxResults": 0,
  "NextToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/search' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": [
    {
      "Name": "",
      "Values": ""
    }
  ],
  "MaxResults": 0,
  "NextToken": ""
}'

import http.client

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

payload = "{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/2015-01-01/es/ccs/outboundConnection/search", payload, headers)

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

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

import requests

url = "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/search"

payload = {
    "Filters": [
        {
            "Name": "",
            "Values": ""
        }
    ],
    "MaxResults": 0,
    "NextToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/search"

payload <- "{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\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-01-01/es/ccs/outboundConnection/search")

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  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\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-01-01/es/ccs/outboundConnection/search') do |req|
  req.body = "{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Values\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/search";

    let payload = json!({
        "Filters": (
            json!({
                "Name": "",
                "Values": ""
            })
        ),
        "MaxResults": 0,
        "NextToken": ""
    });

    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);
}

curl --request POST \
  --url {{baseUrl}}/2015-01-01/es/ccs/outboundConnection/search \
  --header 'content-type: application/json' \
  --data '{
  "Filters": [
    {
      "Name": "",
      "Values": ""
    }
  ],
  "MaxResults": 0,
  "NextToken": ""
}'

echo '{
  "Filters": [
    {
      "Name": "",
      "Values": ""
    }
  ],
  "MaxResults": 0,
  "NextToken": ""
}' |  \
  http POST {{baseUrl}}/2015-01-01/es/ccs/outboundConnection/search \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": [\n    {\n      "Name": "",\n      "Values": ""\n    }\n  ],\n  "MaxResults": 0,\n  "NextToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/ccs/outboundConnection/search

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Filters": [
    [
      "Name": "",
      "Values": ""
    ]
  ],
  "MaxResults": 0,
  "NextToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/ccs/outboundConnection/search")! 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()

POST DescribePackages

{{baseUrl}}/2015-01-01/packages/describe

BODY json

{
  "Filters": [
    {
      "Name": "",
      "Value": ""
    }
  ],
  "MaxResults": 0,
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/packages/describe");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/2015-01-01/packages/describe" {:content-type :json
                                                                         :form-params {:Filters [{:Name ""
                                                                                                  :Value ""}]
                                                                                       :MaxResults 0
                                                                                       :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/2015-01-01/packages/describe"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\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-01-01/packages/describe"),
    Content = new StringContent("{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\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-01-01/packages/describe");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/packages/describe"

	payload := strings.NewReader("{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\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-01-01/packages/describe HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 108

{
  "Filters": [
    {
      "Name": "",
      "Value": ""
    }
  ],
  "MaxResults": 0,
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-01-01/packages/describe")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/packages/describe"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\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  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-01-01/packages/describe")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/2015-01-01/packages/describe")
  .header("content-type", "application/json")
  .body("{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Filters: [
    {
      Name: '',
      Value: ''
    }
  ],
  MaxResults: 0,
  NextToken: ''
});

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-01-01/packages/describe');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/packages/describe',
  headers: {'content-type': 'application/json'},
  data: {Filters: [{Name: '', Value: ''}], MaxResults: 0, NextToken: ''}
};

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

const url = '{{baseUrl}}/2015-01-01/packages/describe';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Filters":[{"Name":"","Value":""}],"MaxResults":0,"NextToken":""}'
};

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-01-01/packages/describe',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filters": [\n    {\n      "Name": "",\n      "Value": ""\n    }\n  ],\n  "MaxResults": 0,\n  "NextToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/packages/describe")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({Filters: [{Name: '', Value: ''}], MaxResults: 0, NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/packages/describe',
  headers: {'content-type': 'application/json'},
  body: {Filters: [{Name: '', Value: ''}], MaxResults: 0, NextToken: ''},
  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-01-01/packages/describe');

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

req.type('json');
req.send({
  Filters: [
    {
      Name: '',
      Value: ''
    }
  ],
  MaxResults: 0,
  NextToken: ''
});

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-01-01/packages/describe',
  headers: {'content-type': 'application/json'},
  data: {Filters: [{Name: '', Value: ''}], MaxResults: 0, NextToken: ''}
};

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

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

const url = '{{baseUrl}}/2015-01-01/packages/describe';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Filters":[{"Name":"","Value":""}],"MaxResults":0,"NextToken":""}'
};

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 = @{ @"Filters": @[ @{ @"Name": @"", @"Value": @"" } ],
                              @"MaxResults": @0,
                              @"NextToken": @"" };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/2015-01-01/packages/describe" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}" in

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

 "{{baseUrl}}/2015-01-01/packages/describe",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Filters' => [
        [
                'Name' => '',
                'Value' => ''
        ]
    ],
    'MaxResults' => 0,
    'NextToken' => ''
  ]),
  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-01-01/packages/describe', [
  'body' => '{
  "Filters": [
    {
      "Name": "",
      "Value": ""
    }
  ],
  "MaxResults": 0,
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/packages/describe');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filters' => [
    [
        'Name' => '',
        'Value' => ''
    ]
  ],
  'MaxResults' => 0,
  'NextToken' => ''
]));

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

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

append(json_encode([
  'Filters' => [
    [
        'Name' => '',
        'Value' => ''
    ]
  ],
  'MaxResults' => 0,
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/2015-01-01/packages/describe');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/packages/describe' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": [
    {
      "Name": "",
      "Value": ""
    }
  ],
  "MaxResults": 0,
  "NextToken": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/packages/describe' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filters": [
    {
      "Name": "",
      "Value": ""
    }
  ],
  "MaxResults": 0,
  "NextToken": ""
}'

import http.client

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

payload = "{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}"

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

conn.request("POST", "/baseUrl/2015-01-01/packages/describe", payload, headers)

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

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

import requests

url = "{{baseUrl}}/2015-01-01/packages/describe"

payload = {
    "Filters": [
        {
            "Name": "",
            "Value": ""
        }
    ],
    "MaxResults": 0,
    "NextToken": ""
}
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/packages/describe"

payload <- "{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\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-01-01/packages/describe")

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

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\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-01-01/packages/describe') do |req|
  req.body = "{\n  \"Filters\": [\n    {\n      \"Name\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"MaxResults\": 0,\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/packages/describe";

    let payload = json!({
        "Filters": (
            json!({
                "Name": "",
                "Value": ""
            })
        ),
        "MaxResults": 0,
        "NextToken": ""
    });

    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);
}

curl --request POST \
  --url {{baseUrl}}/2015-01-01/packages/describe \
  --header 'content-type: application/json' \
  --data '{
  "Filters": [
    {
      "Name": "",
      "Value": ""
    }
  ],
  "MaxResults": 0,
  "NextToken": ""
}'

echo '{
  "Filters": [
    {
      "Name": "",
      "Value": ""
    }
  ],
  "MaxResults": 0,
  "NextToken": ""
}' |  \
  http POST {{baseUrl}}/2015-01-01/packages/describe \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filters": [\n    {\n      "Name": "",\n      "Value": ""\n    }\n  ],\n  "MaxResults": 0,\n  "NextToken": ""\n}' \
  --output-document \
  - {{baseUrl}}/2015-01-01/packages/describe

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "Filters": [
    [
      "Name": "",
      "Value": ""
    ]
  ],
  "MaxResults": 0,
  "NextToken": ""
] as [String : Any]

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

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

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

dataTask.resume()

GET DescribeReservedElasticsearchInstanceOfferings

{{baseUrl}}/2015-01-01/es/reservedInstanceOfferings

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/reservedInstanceOfferings");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2015-01-01/es/reservedInstanceOfferings")

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/reservedInstanceOfferings"

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

var client = new RestClient("{{baseUrl}}/2015-01-01/es/reservedInstanceOfferings");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/es/reservedInstanceOfferings"

	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-01-01/es/reservedInstanceOfferings HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-01-01/es/reservedInstanceOfferings")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/reservedInstanceOfferings"))
    .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-01-01/es/reservedInstanceOfferings")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2015-01-01/es/reservedInstanceOfferings")
  .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-01-01/es/reservedInstanceOfferings');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-01-01/es/reservedInstanceOfferings'
};

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

const url = '{{baseUrl}}/2015-01-01/es/reservedInstanceOfferings';
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-01-01/es/reservedInstanceOfferings',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/reservedInstanceOfferings")
  .get()
  .build()

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

const http = require('https');

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

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-01-01/es/reservedInstanceOfferings');

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-01-01/es/reservedInstanceOfferings'
};

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

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

const url = '{{baseUrl}}/2015-01-01/es/reservedInstanceOfferings';
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-01-01/es/reservedInstanceOfferings"]
                                                       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-01-01/es/reservedInstanceOfferings" in

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

 "{{baseUrl}}/2015-01-01/es/reservedInstanceOfferings",
  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-01-01/es/reservedInstanceOfferings');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/reservedInstanceOfferings');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/2015-01-01/es/reservedInstanceOfferings');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/es/reservedInstanceOfferings' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/reservedInstanceOfferings' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/2015-01-01/es/reservedInstanceOfferings")

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

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

import requests

url = "{{baseUrl}}/2015-01-01/es/reservedInstanceOfferings"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/reservedInstanceOfferings"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/es/reservedInstanceOfferings")

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-01-01/es/reservedInstanceOfferings') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/reservedInstanceOfferings";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/2015-01-01/es/reservedInstanceOfferings

http GET {{baseUrl}}/2015-01-01/es/reservedInstanceOfferings

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/reservedInstanceOfferings

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/reservedInstanceOfferings")! 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()

GET DescribeReservedElasticsearchInstances

{{baseUrl}}/2015-01-01/es/reservedInstances

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/reservedInstances");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2015-01-01/es/reservedInstances")

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/reservedInstances"

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

var client = new RestClient("{{baseUrl}}/2015-01-01/es/reservedInstances");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/es/reservedInstances"

	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-01-01/es/reservedInstances HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-01-01/es/reservedInstances")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/reservedInstances"))
    .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-01-01/es/reservedInstances")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2015-01-01/es/reservedInstances")
  .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-01-01/es/reservedInstances');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-01-01/es/reservedInstances'
};

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

const url = '{{baseUrl}}/2015-01-01/es/reservedInstances';
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-01-01/es/reservedInstances',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/reservedInstances")
  .get()
  .build()

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

const http = require('https');

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

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-01-01/es/reservedInstances');

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-01-01/es/reservedInstances'
};

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

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

const url = '{{baseUrl}}/2015-01-01/es/reservedInstances';
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-01-01/es/reservedInstances"]
                                                       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-01-01/es/reservedInstances" in

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

 "{{baseUrl}}/2015-01-01/es/reservedInstances",
  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-01-01/es/reservedInstances');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/reservedInstances');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/2015-01-01/es/reservedInstances');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/es/reservedInstances' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/reservedInstances' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/2015-01-01/es/reservedInstances")

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

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

import requests

url = "{{baseUrl}}/2015-01-01/es/reservedInstances"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/reservedInstances"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/es/reservedInstances")

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-01-01/es/reservedInstances') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/reservedInstances";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/2015-01-01/es/reservedInstances

http GET {{baseUrl}}/2015-01-01/es/reservedInstances

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/reservedInstances

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/reservedInstances")! 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()

POST DescribeVpcEndpoints

{{baseUrl}}/2015-01-01/es/vpcEndpoints/describe

BODY json

{
  "VpcEndpointIds": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/vpcEndpoints/describe");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"VpcEndpointIds\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/2015-01-01/es/vpcEndpoints/describe" {:content-type :json
                                                                                :form-params {:VpcEndpointIds []}})

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/vpcEndpoints/describe"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"VpcEndpointIds\": []\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-01-01/es/vpcEndpoints/describe"),
    Content = new StringContent("{\n  \"VpcEndpointIds\": []\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-01-01/es/vpcEndpoints/describe");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"VpcEndpointIds\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/es/vpcEndpoints/describe"

	payload := strings.NewReader("{\n  \"VpcEndpointIds\": []\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-01-01/es/vpcEndpoints/describe HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 26

{
  "VpcEndpointIds": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-01-01/es/vpcEndpoints/describe")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"VpcEndpointIds\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/vpcEndpoints/describe"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"VpcEndpointIds\": []\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  \"VpcEndpointIds\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/vpcEndpoints/describe")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/2015-01-01/es/vpcEndpoints/describe")
  .header("content-type", "application/json")
  .body("{\n  \"VpcEndpointIds\": []\n}")
  .asString();

const data = JSON.stringify({
  VpcEndpointIds: []
});

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-01-01/es/vpcEndpoints/describe');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/vpcEndpoints/describe',
  headers: {'content-type': 'application/json'},
  data: {VpcEndpointIds: []}
};

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

const url = '{{baseUrl}}/2015-01-01/es/vpcEndpoints/describe';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"VpcEndpointIds":[]}'
};

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-01-01/es/vpcEndpoints/describe',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "VpcEndpointIds": []\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"VpcEndpointIds\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/vpcEndpoints/describe")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-01-01/es/vpcEndpoints/describe',
  headers: {
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({VpcEndpointIds: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/vpcEndpoints/describe',
  headers: {'content-type': 'application/json'},
  body: {VpcEndpointIds: []},
  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-01-01/es/vpcEndpoints/describe');

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

req.type('json');
req.send({
  VpcEndpointIds: []
});

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-01-01/es/vpcEndpoints/describe',
  headers: {'content-type': 'application/json'},
  data: {VpcEndpointIds: []}
};

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

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

const url = '{{baseUrl}}/2015-01-01/es/vpcEndpoints/describe';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"VpcEndpointIds":[]}'
};

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 = @{ @"VpcEndpointIds": @[  ] };

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

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

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/2015-01-01/es/vpcEndpoints/describe" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"VpcEndpointIds\": []\n}" in

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/vpcEndpoints/describe');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'VpcEndpointIds' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/2015-01-01/es/vpcEndpoints/describe');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/es/vpcEndpoints/describe' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "VpcEndpointIds": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/vpcEndpoints/describe' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "VpcEndpointIds": []
}'

import http.client

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

payload = "{\n  \"VpcEndpointIds\": []\n}"

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

conn.request("POST", "/baseUrl/2015-01-01/es/vpcEndpoints/describe", payload, headers)

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

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

import requests

url = "{{baseUrl}}/2015-01-01/es/vpcEndpoints/describe"

payload = { "VpcEndpointIds": [] }
headers = {"content-type": "application/json"}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/vpcEndpoints/describe"

payload <- "{\n  \"VpcEndpointIds\": []\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-01-01/es/vpcEndpoints/describe")

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/vpcEndpoints/describe";

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

    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);
}

curl --request POST \
  --url {{baseUrl}}/2015-01-01/es/vpcEndpoints/describe \
  --header 'content-type: application/json' \
  --data '{
  "VpcEndpointIds": []
}'

echo '{
  "VpcEndpointIds": []
}' |  \
  http POST {{baseUrl}}/2015-01-01/es/vpcEndpoints/describe \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "VpcEndpointIds": []\n}' \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/vpcEndpoints/describe

import Foundation

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

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

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

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

dataTask.resume()

POST DissociatePackage

{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName

QUERY PARAMS

PackageID

DomainName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName")

require "http/client"

url = "{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName");
var request = new RestRequest("", Method.Post);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName"

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

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

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

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

}

POST /baseUrl/2015-01-01/packages/dissociate/:PackageID/:DomainName HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName"))
    .method("POST", HttpRequest.BodyPublishers.noBody())
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName")
  .post(null)
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName")
  .asString();

const data = null;

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

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

xhr.open('POST', '{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName'
};

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

const url = '{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName';
const options = {method: 'POST'};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName',
  method: 'POST',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName")
  .post(null)
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-01-01/packages/dissociate/:PackageID/:DomainName',
  headers: {}
};

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

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

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

req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName'
};

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-01-01/packages/dissociate/:PackageID/:DomainName');

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-01-01/packages/dissociate/:PackageID/:DomainName'
};

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

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

const url = '{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName';
const options = {method: 'POST'};

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

#import 

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName" in

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

 "{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName');
$request->setMethod(HTTP_METH_POST);

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

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

setRequestUrl('{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName');
$request->setRequestMethod('POST');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName' -Method POST

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName' -Method POST

import http.client

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

conn.request("POST", "/baseUrl/2015-01-01/packages/dissociate/:PackageID/:DomainName")

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

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

import requests

url = "{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName"

response = requests.post(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/2015-01-01/packages/dissociate/:PackageID/:DomainName') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName";

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

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

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName

http POST {{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName

wget --quiet \
  --method POST \
  --output-document \
  - {{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/packages/dissociate/:PackageID/:DomainName")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"

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

dataTask.resume()

GET GetCompatibleElasticsearchVersions

{{baseUrl}}/2015-01-01/es/compatibleVersions

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/compatibleVersions");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2015-01-01/es/compatibleVersions")

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/compatibleVersions"

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

var client = new RestClient("{{baseUrl}}/2015-01-01/es/compatibleVersions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/es/compatibleVersions"

	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-01-01/es/compatibleVersions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-01-01/es/compatibleVersions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/compatibleVersions"))
    .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-01-01/es/compatibleVersions")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2015-01-01/es/compatibleVersions")
  .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-01-01/es/compatibleVersions');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-01-01/es/compatibleVersions'
};

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

const url = '{{baseUrl}}/2015-01-01/es/compatibleVersions';
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-01-01/es/compatibleVersions',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/compatibleVersions")
  .get()
  .build()

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

const http = require('https');

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

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-01-01/es/compatibleVersions');

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-01-01/es/compatibleVersions'
};

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

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

const url = '{{baseUrl}}/2015-01-01/es/compatibleVersions';
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-01-01/es/compatibleVersions"]
                                                       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-01-01/es/compatibleVersions" in

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

 "{{baseUrl}}/2015-01-01/es/compatibleVersions",
  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-01-01/es/compatibleVersions');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/compatibleVersions');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/2015-01-01/es/compatibleVersions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/es/compatibleVersions' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/compatibleVersions' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/2015-01-01/es/compatibleVersions")

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

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

import requests

url = "{{baseUrl}}/2015-01-01/es/compatibleVersions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/compatibleVersions"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/es/compatibleVersions")

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-01-01/es/compatibleVersions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/compatibleVersions";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/2015-01-01/es/compatibleVersions

http GET {{baseUrl}}/2015-01-01/es/compatibleVersions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/compatibleVersions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/compatibleVersions")! 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()

GET GetPackageVersionHistory

{{baseUrl}}/2015-01-01/packages/:PackageID/history

QUERY PARAMS

PackageID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/packages/:PackageID/history");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2015-01-01/packages/:PackageID/history")

require "http/client"

url = "{{baseUrl}}/2015-01-01/packages/:PackageID/history"

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

var client = new RestClient("{{baseUrl}}/2015-01-01/packages/:PackageID/history");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/packages/:PackageID/history"

	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-01-01/packages/:PackageID/history HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-01-01/packages/:PackageID/history")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/packages/:PackageID/history"))
    .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-01-01/packages/:PackageID/history")
  .get()
  .build();

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

HttpResponse response = Unirest.get("{{baseUrl}}/2015-01-01/packages/:PackageID/history")
  .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-01-01/packages/:PackageID/history');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-01-01/packages/:PackageID/history'
};

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

const url = '{{baseUrl}}/2015-01-01/packages/:PackageID/history';
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-01-01/packages/:PackageID/history',
  method: 'GET',
  headers: {}
};

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

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/packages/:PackageID/history")
  .get()
  .build()

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

const http = require('https');

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

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-01-01/packages/:PackageID/history');

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-01-01/packages/:PackageID/history'
};

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

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

const url = '{{baseUrl}}/2015-01-01/packages/:PackageID/history';
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-01-01/packages/:PackageID/history"]
                                                       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-01-01/packages/:PackageID/history" in

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

 "{{baseUrl}}/2015-01-01/packages/:PackageID/history",
  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-01-01/packages/:PackageID/history');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/packages/:PackageID/history');
$request->setMethod(HTTP_METH_GET);

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

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

setRequestUrl('{{baseUrl}}/2015-01-01/packages/:PackageID/history');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/packages/:PackageID/history' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/packages/:PackageID/history' -Method GET

import http.client

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

conn.request("GET", "/baseUrl/2015-01-01/packages/:PackageID/history")

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

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

import requests

url = "{{baseUrl}}/2015-01-01/packages/:PackageID/history"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/packages/:PackageID/history"

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

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/packages/:PackageID/history")

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-01-01/packages/:PackageID/history') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/packages/:PackageID/history";

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

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

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/2015-01-01/packages/:PackageID/history

http GET {{baseUrl}}/2015-01-01/packages/:PackageID/history

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-01-01/packages/:PackageID/history

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/packages/:PackageID/history")! 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()

GET GetUpgradeHistory

{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/history

QUERY PARAMS

DomainName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/history");

CURLcode ret = curl_easy_perform(hnd);

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

(client/get "{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/history")

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/history"

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

var client = new RestClient("{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/history");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/history"

	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-01-01/es/upgradeDomain/:DomainName/history HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/history")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/history"))
    .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-01-01/es/upgradeDomain/:DomainName/history")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/history")
  .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-01-01/es/upgradeDomain/:DomainName/history');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/history'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/history';
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-01-01/es/upgradeDomain/:DomainName/history',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/history")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-01-01/es/upgradeDomain/:DomainName/history',
  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-01-01/es/upgradeDomain/:DomainName/history'
};

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-01-01/es/upgradeDomain/:DomainName/history');

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-01-01/es/upgradeDomain/:DomainName/history'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/history';
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-01-01/es/upgradeDomain/:DomainName/history"]
                                                       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-01-01/es/upgradeDomain/:DomainName/history" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/history",
  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-01-01/es/upgradeDomain/:DomainName/history');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/history');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/history');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/history' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/history' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/2015-01-01/es/upgradeDomain/:DomainName/history")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/history"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/history"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/history")

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-01-01/es/upgradeDomain/:DomainName/history') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/history";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/history

http GET {{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/history

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/history

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/history")! 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()

GET GetUpgradeStatus

{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/status

QUERY PARAMS

DomainName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/status");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/status")

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/status"

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-01-01/es/upgradeDomain/:DomainName/status"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/status");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/status"

	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-01-01/es/upgradeDomain/:DomainName/status HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/status")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/status"))
    .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-01-01/es/upgradeDomain/:DomainName/status")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/status")
  .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-01-01/es/upgradeDomain/:DomainName/status');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/status'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/status';
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-01-01/es/upgradeDomain/:DomainName/status',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/status")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-01-01/es/upgradeDomain/:DomainName/status',
  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-01-01/es/upgradeDomain/:DomainName/status'
};

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-01-01/es/upgradeDomain/:DomainName/status');

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-01-01/es/upgradeDomain/:DomainName/status'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/status';
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-01-01/es/upgradeDomain/:DomainName/status"]
                                                       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-01-01/es/upgradeDomain/:DomainName/status" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/status",
  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-01-01/es/upgradeDomain/:DomainName/status');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/status');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/status');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/status' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/status' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/2015-01-01/es/upgradeDomain/:DomainName/status")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/status"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/status"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/status")

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-01-01/es/upgradeDomain/:DomainName/status') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/status";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/status

http GET {{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/status

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/status

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/upgradeDomain/:DomainName/status")! 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()

GET ListDomainNames

{{baseUrl}}/2015-01-01/domain

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/domain");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/2015-01-01/domain")

require "http/client"

url = "{{baseUrl}}/2015-01-01/domain"

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-01-01/domain"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2015-01-01/domain");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2015-01-01/domain"

	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-01-01/domain HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-01-01/domain")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/domain"))
    .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-01-01/domain")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/2015-01-01/domain")
  .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-01-01/domain');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/2015-01-01/domain'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2015-01-01/domain';
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-01-01/domain',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/domain")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-01-01/domain',
  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-01-01/domain'};

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-01-01/domain');

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-01-01/domain'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2015-01-01/domain';
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-01-01/domain"]
                                                       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-01-01/domain" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2015-01-01/domain",
  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-01-01/domain');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/domain');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/2015-01-01/domain');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/domain' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/domain' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/2015-01-01/domain")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2015-01-01/domain"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/domain"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/domain")

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-01-01/domain') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/domain";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/2015-01-01/domain

http GET {{baseUrl}}/2015-01-01/domain

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-01-01/domain

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/domain")! 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()

GET ListDomainsForPackage

{{baseUrl}}/2015-01-01/packages/:PackageID/domains

QUERY PARAMS

PackageID

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/packages/:PackageID/domains");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/2015-01-01/packages/:PackageID/domains")

require "http/client"

url = "{{baseUrl}}/2015-01-01/packages/:PackageID/domains"

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-01-01/packages/:PackageID/domains"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2015-01-01/packages/:PackageID/domains");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2015-01-01/packages/:PackageID/domains"

	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-01-01/packages/:PackageID/domains HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-01-01/packages/:PackageID/domains")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/packages/:PackageID/domains"))
    .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-01-01/packages/:PackageID/domains")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/2015-01-01/packages/:PackageID/domains")
  .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-01-01/packages/:PackageID/domains');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-01-01/packages/:PackageID/domains'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2015-01-01/packages/:PackageID/domains';
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-01-01/packages/:PackageID/domains',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/packages/:PackageID/domains")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-01-01/packages/:PackageID/domains',
  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-01-01/packages/:PackageID/domains'
};

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-01-01/packages/:PackageID/domains');

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-01-01/packages/:PackageID/domains'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2015-01-01/packages/:PackageID/domains';
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-01-01/packages/:PackageID/domains"]
                                                       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-01-01/packages/:PackageID/domains" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2015-01-01/packages/:PackageID/domains",
  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-01-01/packages/:PackageID/domains');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/packages/:PackageID/domains');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/2015-01-01/packages/:PackageID/domains');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/packages/:PackageID/domains' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/packages/:PackageID/domains' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/2015-01-01/packages/:PackageID/domains")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2015-01-01/packages/:PackageID/domains"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/packages/:PackageID/domains"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/packages/:PackageID/domains")

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-01-01/packages/:PackageID/domains') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/packages/:PackageID/domains";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/2015-01-01/packages/:PackageID/domains

http GET {{baseUrl}}/2015-01-01/packages/:PackageID/domains

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-01-01/packages/:PackageID/domains

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/packages/:PackageID/domains")! 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()

GET ListElasticsearchInstanceTypes

{{baseUrl}}/2015-01-01/es/instanceTypes/:ElasticsearchVersion

QUERY PARAMS

ElasticsearchVersion

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/instanceTypes/:ElasticsearchVersion");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/2015-01-01/es/instanceTypes/:ElasticsearchVersion")

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/instanceTypes/:ElasticsearchVersion"

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-01-01/es/instanceTypes/:ElasticsearchVersion"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2015-01-01/es/instanceTypes/:ElasticsearchVersion");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2015-01-01/es/instanceTypes/:ElasticsearchVersion"

	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-01-01/es/instanceTypes/:ElasticsearchVersion HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-01-01/es/instanceTypes/:ElasticsearchVersion")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/instanceTypes/:ElasticsearchVersion"))
    .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-01-01/es/instanceTypes/:ElasticsearchVersion")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/2015-01-01/es/instanceTypes/:ElasticsearchVersion")
  .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-01-01/es/instanceTypes/:ElasticsearchVersion');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-01-01/es/instanceTypes/:ElasticsearchVersion'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2015-01-01/es/instanceTypes/:ElasticsearchVersion';
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-01-01/es/instanceTypes/:ElasticsearchVersion',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/instanceTypes/:ElasticsearchVersion")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-01-01/es/instanceTypes/:ElasticsearchVersion',
  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-01-01/es/instanceTypes/:ElasticsearchVersion'
};

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-01-01/es/instanceTypes/:ElasticsearchVersion');

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-01-01/es/instanceTypes/:ElasticsearchVersion'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2015-01-01/es/instanceTypes/:ElasticsearchVersion';
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-01-01/es/instanceTypes/:ElasticsearchVersion"]
                                                       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-01-01/es/instanceTypes/:ElasticsearchVersion" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2015-01-01/es/instanceTypes/:ElasticsearchVersion",
  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-01-01/es/instanceTypes/:ElasticsearchVersion');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/instanceTypes/:ElasticsearchVersion');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/2015-01-01/es/instanceTypes/:ElasticsearchVersion');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/es/instanceTypes/:ElasticsearchVersion' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/instanceTypes/:ElasticsearchVersion' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/2015-01-01/es/instanceTypes/:ElasticsearchVersion")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2015-01-01/es/instanceTypes/:ElasticsearchVersion"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/instanceTypes/:ElasticsearchVersion"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/es/instanceTypes/:ElasticsearchVersion")

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-01-01/es/instanceTypes/:ElasticsearchVersion') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/instanceTypes/:ElasticsearchVersion";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/2015-01-01/es/instanceTypes/:ElasticsearchVersion

http GET {{baseUrl}}/2015-01-01/es/instanceTypes/:ElasticsearchVersion

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/instanceTypes/:ElasticsearchVersion

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/instanceTypes/:ElasticsearchVersion")! 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()

GET ListElasticsearchVersions

{{baseUrl}}/2015-01-01/es/versions

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/versions");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/2015-01-01/es/versions")

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/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-01-01/es/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-01-01/es/versions");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2015-01-01/es/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-01-01/es/versions HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-01-01/es/versions")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/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-01-01/es/versions")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/2015-01-01/es/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-01-01/es/versions');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/2015-01-01/es/versions'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2015-01-01/es/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-01-01/es/versions',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/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-01-01/es/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-01-01/es/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-01-01/es/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-01-01/es/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-01-01/es/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-01-01/es/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-01-01/es/versions" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2015-01-01/es/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-01-01/es/versions');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/versions');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/2015-01-01/es/versions');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/es/versions' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/versions' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/2015-01-01/es/versions")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2015-01-01/es/versions"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/versions"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/es/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-01-01/es/versions') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/versions";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/2015-01-01/es/versions

http GET {{baseUrl}}/2015-01-01/es/versions

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/versions

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/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()

GET ListPackagesForDomain

{{baseUrl}}/2015-01-01/domain/:DomainName/packages

QUERY PARAMS

DomainName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/domain/:DomainName/packages");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/2015-01-01/domain/:DomainName/packages")

require "http/client"

url = "{{baseUrl}}/2015-01-01/domain/:DomainName/packages"

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-01-01/domain/:DomainName/packages"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2015-01-01/domain/:DomainName/packages");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2015-01-01/domain/:DomainName/packages"

	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-01-01/domain/:DomainName/packages HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-01-01/domain/:DomainName/packages")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/domain/:DomainName/packages"))
    .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-01-01/domain/:DomainName/packages")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/2015-01-01/domain/:DomainName/packages")
  .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-01-01/domain/:DomainName/packages');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-01-01/domain/:DomainName/packages'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2015-01-01/domain/:DomainName/packages';
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-01-01/domain/:DomainName/packages',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/domain/:DomainName/packages")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-01-01/domain/:DomainName/packages',
  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-01-01/domain/:DomainName/packages'
};

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-01-01/domain/:DomainName/packages');

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-01-01/domain/:DomainName/packages'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2015-01-01/domain/:DomainName/packages';
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-01-01/domain/:DomainName/packages"]
                                                       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-01-01/domain/:DomainName/packages" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2015-01-01/domain/:DomainName/packages",
  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-01-01/domain/:DomainName/packages');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/domain/:DomainName/packages');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/2015-01-01/domain/:DomainName/packages');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/domain/:DomainName/packages' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/domain/:DomainName/packages' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/2015-01-01/domain/:DomainName/packages")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2015-01-01/domain/:DomainName/packages"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/domain/:DomainName/packages"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/domain/:DomainName/packages")

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-01-01/domain/:DomainName/packages') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/domain/:DomainName/packages";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/2015-01-01/domain/:DomainName/packages

http GET {{baseUrl}}/2015-01-01/domain/:DomainName/packages

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-01-01/domain/:DomainName/packages

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/domain/:DomainName/packages")! 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()

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/tags/?arn=#arn");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/2015-01-01/tags/#arn" {:query-params {:arn ""}})

require "http/client"

url = "{{baseUrl}}/2015-01-01/tags/?arn=#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}}/2015-01-01/tags/?arn=#arn"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2015-01-01/tags/?arn=#arn");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2015-01-01/tags/?arn=#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/2015-01-01/tags/?arn= HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-01-01/tags/?arn=#arn")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/tags/?arn=#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}}/2015-01-01/tags/?arn=#arn")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/2015-01-01/tags/?arn=#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}}/2015-01-01/tags/?arn=#arn');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-01-01/tags/#arn',
  params: {arn: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2015-01-01/tags/?arn=#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}}/2015-01-01/tags/?arn=#arn',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/tags/?arn=#arn")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-01-01/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}}/2015-01-01/tags/#arn',
  qs: {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}}/2015-01-01/tags/#arn');

req.query({
  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}}/2015-01-01/tags/#arn',
  params: {arn: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2015-01-01/tags/?arn=#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}}/2015-01-01/tags/?arn=#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}}/2015-01-01/tags/?arn=#arn" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2015-01-01/tags/?arn=#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}}/2015-01-01/tags/?arn=#arn');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/tags/#arn');
$request->setMethod(HTTP_METH_GET);

$request->setQueryData([
  'arn' => ''
]);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/2015-01-01/tags/#arn');
$request->setRequestMethod('GET');
$request->setQuery(new http\QueryString([
  'arn' => ''
]));

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/tags/?arn=#arn' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/tags/?arn=#arn' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/2015-01-01/tags/?arn=")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2015-01-01/tags/#arn"

querystring = {"arn":""}

response = requests.get(url, params=querystring)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/tags/#arn"

queryString <- list(arn = "")

response <- VERB("GET", url, query = queryString, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/tags/?arn=#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/2015-01-01/tags/') do |req|
  req.params['arn'] = ''
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/tags/#arn";

    let querystring = [
        ("arn", ""),
    ];

    let client = reqwest::Client::new();
    let response = client.get(url)
        .query(&querystring)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url '{{baseUrl}}/2015-01-01/tags/?arn=#arn'

http GET '{{baseUrl}}/2015-01-01/tags/?arn=#arn'

wget --quiet \
  --method GET \
  --output-document \
  - '{{baseUrl}}/2015-01-01/tags/?arn=#arn'

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/tags/?arn=#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()

GET ListVpcEndpointAccess

{{baseUrl}}/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess

QUERY PARAMS

DomainName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess")

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess"

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-01-01/es/domain/:DomainName/listVpcEndpointAccess"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess"

	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-01-01/es/domain/:DomainName/listVpcEndpointAccess HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess"))
    .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-01-01/es/domain/:DomainName/listVpcEndpointAccess")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess")
  .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-01-01/es/domain/:DomainName/listVpcEndpointAccess');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess';
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-01-01/es/domain/:DomainName/listVpcEndpointAccess',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess',
  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-01-01/es/domain/:DomainName/listVpcEndpointAccess'
};

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-01-01/es/domain/:DomainName/listVpcEndpointAccess');

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-01-01/es/domain/:DomainName/listVpcEndpointAccess'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess';
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-01-01/es/domain/:DomainName/listVpcEndpointAccess"]
                                                       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-01-01/es/domain/:DomainName/listVpcEndpointAccess" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess",
  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-01-01/es/domain/:DomainName/listVpcEndpointAccess');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess")

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-01-01/es/domain/:DomainName/listVpcEndpointAccess') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess

http GET {{baseUrl}}/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/domain/:DomainName/listVpcEndpointAccess")! 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()

GET ListVpcEndpoints

{{baseUrl}}/2015-01-01/es/vpcEndpoints

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/vpcEndpoints");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/2015-01-01/es/vpcEndpoints")

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/vpcEndpoints"

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-01-01/es/vpcEndpoints"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2015-01-01/es/vpcEndpoints");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2015-01-01/es/vpcEndpoints"

	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-01-01/es/vpcEndpoints HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-01-01/es/vpcEndpoints")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/vpcEndpoints"))
    .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-01-01/es/vpcEndpoints")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/2015-01-01/es/vpcEndpoints")
  .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-01-01/es/vpcEndpoints');

xhr.send(data);

import axios from 'axios';

const options = {method: 'GET', url: '{{baseUrl}}/2015-01-01/es/vpcEndpoints'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2015-01-01/es/vpcEndpoints';
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-01-01/es/vpcEndpoints',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/vpcEndpoints")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-01-01/es/vpcEndpoints',
  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-01-01/es/vpcEndpoints'};

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-01-01/es/vpcEndpoints');

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-01-01/es/vpcEndpoints'};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2015-01-01/es/vpcEndpoints';
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-01-01/es/vpcEndpoints"]
                                                       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-01-01/es/vpcEndpoints" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2015-01-01/es/vpcEndpoints",
  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-01-01/es/vpcEndpoints');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/vpcEndpoints');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/2015-01-01/es/vpcEndpoints');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/es/vpcEndpoints' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/vpcEndpoints' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/2015-01-01/es/vpcEndpoints")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2015-01-01/es/vpcEndpoints"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/vpcEndpoints"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/es/vpcEndpoints")

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-01-01/es/vpcEndpoints') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/vpcEndpoints";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/2015-01-01/es/vpcEndpoints

http GET {{baseUrl}}/2015-01-01/es/vpcEndpoints

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/vpcEndpoints

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/vpcEndpoints")! 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()

GET ListVpcEndpointsForDomain

{{baseUrl}}/2015-01-01/es/domain/:DomainName/vpcEndpoints

QUERY PARAMS

DomainName

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "GET");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/domain/:DomainName/vpcEndpoints");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/get "{{baseUrl}}/2015-01-01/es/domain/:DomainName/vpcEndpoints")

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName/vpcEndpoints"

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-01-01/es/domain/:DomainName/vpcEndpoints"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2015-01-01/es/domain/:DomainName/vpcEndpoints");
var request = new RestRequest("", Method.Get);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2015-01-01/es/domain/:DomainName/vpcEndpoints"

	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-01-01/es/domain/:DomainName/vpcEndpoints HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("GET", "{{baseUrl}}/2015-01-01/es/domain/:DomainName/vpcEndpoints")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/domain/:DomainName/vpcEndpoints"))
    .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-01-01/es/domain/:DomainName/vpcEndpoints")
  .get()
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.get("{{baseUrl}}/2015-01-01/es/domain/:DomainName/vpcEndpoints")
  .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-01-01/es/domain/:DomainName/vpcEndpoints');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'GET',
  url: '{{baseUrl}}/2015-01-01/es/domain/:DomainName/vpcEndpoints'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2015-01-01/es/domain/:DomainName/vpcEndpoints';
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-01-01/es/domain/:DomainName/vpcEndpoints',
  method: 'GET',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/domain/:DomainName/vpcEndpoints")
  .get()
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'GET',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-01-01/es/domain/:DomainName/vpcEndpoints',
  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-01-01/es/domain/:DomainName/vpcEndpoints'
};

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-01-01/es/domain/:DomainName/vpcEndpoints');

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-01-01/es/domain/:DomainName/vpcEndpoints'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2015-01-01/es/domain/:DomainName/vpcEndpoints';
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-01-01/es/domain/:DomainName/vpcEndpoints"]
                                                       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-01-01/es/domain/:DomainName/vpcEndpoints" in

Client.call `GET uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2015-01-01/es/domain/:DomainName/vpcEndpoints",
  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-01-01/es/domain/:DomainName/vpcEndpoints');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/domain/:DomainName/vpcEndpoints');
$request->setMethod(HTTP_METH_GET);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/2015-01-01/es/domain/:DomainName/vpcEndpoints');
$request->setRequestMethod('GET');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/es/domain/:DomainName/vpcEndpoints' -Method GET

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/domain/:DomainName/vpcEndpoints' -Method GET

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("GET", "/baseUrl/2015-01-01/es/domain/:DomainName/vpcEndpoints")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName/vpcEndpoints"

response = requests.get(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/domain/:DomainName/vpcEndpoints"

response <- VERB("GET", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/es/domain/:DomainName/vpcEndpoints")

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-01-01/es/domain/:DomainName/vpcEndpoints') do |req|
end

puts response.status
puts response.body

use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName/vpcEndpoints";

    let client = reqwest::Client::new();
    let response = client.get(url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request GET \
  --url {{baseUrl}}/2015-01-01/es/domain/:DomainName/vpcEndpoints

http GET {{baseUrl}}/2015-01-01/es/domain/:DomainName/vpcEndpoints

wget --quiet \
  --method GET \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/domain/:DomainName/vpcEndpoints

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/domain/:DomainName/vpcEndpoints")! 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()

POST PurchaseReservedElasticsearchInstanceOffering

{{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering

BODY json

{
  "ReservedElasticsearchInstanceOfferingId": "",
  "ReservationName": "",
  "InstanceCount": 0
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering");

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  \"ReservedElasticsearchInstanceOfferingId\": \"\",\n  \"ReservationName\": \"\",\n  \"InstanceCount\": 0\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering" {:content-type :json
                                                                                           :form-params {:ReservedElasticsearchInstanceOfferingId ""
                                                                                                         :ReservationName ""
                                                                                                         :InstanceCount 0}})

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ReservedElasticsearchInstanceOfferingId\": \"\",\n  \"ReservationName\": \"\",\n  \"InstanceCount\": 0\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-01-01/es/purchaseReservedInstanceOffering"),
    Content = new StringContent("{\n  \"ReservedElasticsearchInstanceOfferingId\": \"\",\n  \"ReservationName\": \"\",\n  \"InstanceCount\": 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}}/2015-01-01/es/purchaseReservedInstanceOffering");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ReservedElasticsearchInstanceOfferingId\": \"\",\n  \"ReservationName\": \"\",\n  \"InstanceCount\": 0\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering"

	payload := strings.NewReader("{\n  \"ReservedElasticsearchInstanceOfferingId\": \"\",\n  \"ReservationName\": \"\",\n  \"InstanceCount\": 0\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-01-01/es/purchaseReservedInstanceOffering HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 98

{
  "ReservedElasticsearchInstanceOfferingId": "",
  "ReservationName": "",
  "InstanceCount": 0
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ReservedElasticsearchInstanceOfferingId\": \"\",\n  \"ReservationName\": \"\",\n  \"InstanceCount\": 0\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ReservedElasticsearchInstanceOfferingId\": \"\",\n  \"ReservationName\": \"\",\n  \"InstanceCount\": 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  \"ReservedElasticsearchInstanceOfferingId\": \"\",\n  \"ReservationName\": \"\",\n  \"InstanceCount\": 0\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering")
  .header("content-type", "application/json")
  .body("{\n  \"ReservedElasticsearchInstanceOfferingId\": \"\",\n  \"ReservationName\": \"\",\n  \"InstanceCount\": 0\n}")
  .asString();

const data = JSON.stringify({
  ReservedElasticsearchInstanceOfferingId: '',
  ReservationName: '',
  InstanceCount: 0
});

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-01-01/es/purchaseReservedInstanceOffering');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering',
  headers: {'content-type': 'application/json'},
  data: {
    ReservedElasticsearchInstanceOfferingId: '',
    ReservationName: '',
    InstanceCount: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ReservedElasticsearchInstanceOfferingId":"","ReservationName":"","InstanceCount":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}}/2015-01-01/es/purchaseReservedInstanceOffering',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ReservedElasticsearchInstanceOfferingId": "",\n  "ReservationName": "",\n  "InstanceCount": 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  \"ReservedElasticsearchInstanceOfferingId\": \"\",\n  \"ReservationName\": \"\",\n  \"InstanceCount\": 0\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering")
  .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-01-01/es/purchaseReservedInstanceOffering',
  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({
  ReservedElasticsearchInstanceOfferingId: '',
  ReservationName: '',
  InstanceCount: 0
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering',
  headers: {'content-type': 'application/json'},
  body: {
    ReservedElasticsearchInstanceOfferingId: '',
    ReservationName: '',
    InstanceCount: 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('POST', '{{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ReservedElasticsearchInstanceOfferingId: '',
  ReservationName: '',
  InstanceCount: 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: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering',
  headers: {'content-type': 'application/json'},
  data: {
    ReservedElasticsearchInstanceOfferingId: '',
    ReservationName: '',
    InstanceCount: 0
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ReservedElasticsearchInstanceOfferingId":"","ReservationName":"","InstanceCount":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 = @{ @"ReservedElasticsearchInstanceOfferingId": @"",
                              @"ReservationName": @"",
                              @"InstanceCount": @0 };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering"]
                                                       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-01-01/es/purchaseReservedInstanceOffering" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ReservedElasticsearchInstanceOfferingId\": \"\",\n  \"ReservationName\": \"\",\n  \"InstanceCount\": 0\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering",
  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([
    'ReservedElasticsearchInstanceOfferingId' => '',
    'ReservationName' => '',
    'InstanceCount' => 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('POST', '{{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering', [
  'body' => '{
  "ReservedElasticsearchInstanceOfferingId": "",
  "ReservationName": "",
  "InstanceCount": 0
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ReservedElasticsearchInstanceOfferingId' => '',
  'ReservationName' => '',
  'InstanceCount' => 0
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ReservedElasticsearchInstanceOfferingId' => '',
  'ReservationName' => '',
  'InstanceCount' => 0
]));
$request->setRequestUrl('{{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering');
$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-01-01/es/purchaseReservedInstanceOffering' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ReservedElasticsearchInstanceOfferingId": "",
  "ReservationName": "",
  "InstanceCount": 0
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ReservedElasticsearchInstanceOfferingId": "",
  "ReservationName": "",
  "InstanceCount": 0
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ReservedElasticsearchInstanceOfferingId\": \"\",\n  \"ReservationName\": \"\",\n  \"InstanceCount\": 0\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/2015-01-01/es/purchaseReservedInstanceOffering", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering"

payload = {
    "ReservedElasticsearchInstanceOfferingId": "",
    "ReservationName": "",
    "InstanceCount": 0
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering"

payload <- "{\n  \"ReservedElasticsearchInstanceOfferingId\": \"\",\n  \"ReservationName\": \"\",\n  \"InstanceCount\": 0\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-01-01/es/purchaseReservedInstanceOffering")

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  \"ReservedElasticsearchInstanceOfferingId\": \"\",\n  \"ReservationName\": \"\",\n  \"InstanceCount\": 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.post('/baseUrl/2015-01-01/es/purchaseReservedInstanceOffering') do |req|
  req.body = "{\n  \"ReservedElasticsearchInstanceOfferingId\": \"\",\n  \"ReservationName\": \"\",\n  \"InstanceCount\": 0\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering";

    let payload = json!({
        "ReservedElasticsearchInstanceOfferingId": "",
        "ReservationName": "",
        "InstanceCount": 0
    });

    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);
}

curl --request POST \
  --url {{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering \
  --header 'content-type: application/json' \
  --data '{
  "ReservedElasticsearchInstanceOfferingId": "",
  "ReservationName": "",
  "InstanceCount": 0
}'

echo '{
  "ReservedElasticsearchInstanceOfferingId": "",
  "ReservationName": "",
  "InstanceCount": 0
}' |  \
  http POST {{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ReservedElasticsearchInstanceOfferingId": "",\n  "ReservationName": "",\n  "InstanceCount": 0\n}' \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "ReservedElasticsearchInstanceOfferingId": "",
  "ReservationName": "",
  "InstanceCount": 0
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/purchaseReservedInstanceOffering")! 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()

PUT RejectInboundCrossClusterSearchConnection

{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject

QUERY PARAMS

ConnectionId

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "PUT");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/put "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject")

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject"

response = HTTP::Client.put url
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Put,
    RequestUri = new Uri("{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject"),
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject");
var request = new RestRequest("", Method.Put);
var response = client.Execute(request);

package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject"

	req, _ := http.NewRequest("PUT", url, nil)

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

PUT /baseUrl/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject HTTP/1.1
Host: example.com

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("PUT", "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject"))
    .method("PUT", 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-01-01/es/ccs/inboundConnection/:ConnectionId/reject")
  .put(null)
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.put("{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject")
  .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('PUT', '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'PUT',
  url: '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject';
const options = {method: 'PUT'};

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-01-01/es/ccs/inboundConnection/:ConnectionId/reject',
  method: 'PUT',
  headers: {}
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject")
  .put(null)
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'PUT',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject',
  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: 'PUT',
  url: '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject'
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('PUT', '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject');

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}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject'
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject';
const options = {method: 'PUT'};

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-01-01/es/ccs/inboundConnection/:ConnectionId/reject"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"PUT"];

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-01-01/es/ccs/inboundConnection/:ConnectionId/reject" in

Client.call `PUT uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "PUT",
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('PUT', '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject');

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject');
$request->setMethod(HTTP_METH_PUT);

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

setRequestUrl('{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject');
$request->setRequestMethod('PUT');
$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject' -Method PUT

$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject' -Method PUT

import http.client

conn = http.client.HTTPSConnection("example.com")

conn.request("PUT", "/baseUrl/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject")

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject"

response = requests.put(url)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject"

response <- VERB("PUT", url, content_type("application/octet-stream"))

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Put.new(url)

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
)

response = conn.put('/baseUrl/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject') 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-01-01/es/ccs/inboundConnection/:ConnectionId/reject";

    let client = reqwest::Client::new();
    let response = client.request(reqwest::Method::from_str("PUT").unwrap(), url)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request PUT \
  --url {{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject

http PUT {{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject

wget --quiet \
  --method PUT \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject

import Foundation

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/ccs/inboundConnection/:ConnectionId/reject")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PUT"

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()

POST RemoveTags

{{baseUrl}}/2015-01-01/tags-removal

BODY json

{
  "ARN": "",
  "TagKeys": []
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/tags-removal");

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  \"ARN\": \"\",\n  \"TagKeys\": []\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/2015-01-01/tags-removal" {:content-type :json
                                                                    :form-params {:ARN ""
                                                                                  :TagKeys []}})

require "http/client"

url = "{{baseUrl}}/2015-01-01/tags-removal"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ARN\": \"\",\n  \"TagKeys\": []\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-01-01/tags-removal"),
    Content = new StringContent("{\n  \"ARN\": \"\",\n  \"TagKeys\": []\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-01-01/tags-removal");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ARN\": \"\",\n  \"TagKeys\": []\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2015-01-01/tags-removal"

	payload := strings.NewReader("{\n  \"ARN\": \"\",\n  \"TagKeys\": []\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-01-01/tags-removal HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 32

{
  "ARN": "",
  "TagKeys": []
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-01-01/tags-removal")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ARN\": \"\",\n  \"TagKeys\": []\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/tags-removal"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ARN\": \"\",\n  \"TagKeys\": []\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  \"ARN\": \"\",\n  \"TagKeys\": []\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-01-01/tags-removal")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/2015-01-01/tags-removal")
  .header("content-type", "application/json")
  .body("{\n  \"ARN\": \"\",\n  \"TagKeys\": []\n}")
  .asString();

const data = JSON.stringify({
  ARN: '',
  TagKeys: []
});

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-01-01/tags-removal');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/tags-removal',
  headers: {'content-type': 'application/json'},
  data: {ARN: '', TagKeys: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2015-01-01/tags-removal';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ARN":"","TagKeys":[]}'
};

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-01-01/tags-removal',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ARN": "",\n  "TagKeys": []\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ARN\": \"\",\n  \"TagKeys\": []\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/tags-removal")
  .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-01-01/tags-removal',
  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({ARN: '', TagKeys: []}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/tags-removal',
  headers: {'content-type': 'application/json'},
  body: {ARN: '', TagKeys: []},
  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-01-01/tags-removal');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ARN: '',
  TagKeys: []
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/tags-removal',
  headers: {'content-type': 'application/json'},
  data: {ARN: '', TagKeys: []}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2015-01-01/tags-removal';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ARN":"","TagKeys":[]}'
};

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 = @{ @"ARN": @"",
                              @"TagKeys": @[  ] };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-01-01/tags-removal"]
                                                       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-01-01/tags-removal" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ARN\": \"\",\n  \"TagKeys\": []\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2015-01-01/tags-removal",
  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([
    'ARN' => '',
    'TagKeys' => [
        
    ]
  ]),
  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-01-01/tags-removal', [
  'body' => '{
  "ARN": "",
  "TagKeys": []
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/tags-removal');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ARN' => '',
  'TagKeys' => [
    
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ARN' => '',
  'TagKeys' => [
    
  ]
]));
$request->setRequestUrl('{{baseUrl}}/2015-01-01/tags-removal');
$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-01-01/tags-removal' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ARN": "",
  "TagKeys": []
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/tags-removal' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ARN": "",
  "TagKeys": []
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ARN\": \"\",\n  \"TagKeys\": []\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/2015-01-01/tags-removal", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2015-01-01/tags-removal"

payload = {
    "ARN": "",
    "TagKeys": []
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/tags-removal"

payload <- "{\n  \"ARN\": \"\",\n  \"TagKeys\": []\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-01-01/tags-removal")

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  \"ARN\": \"\",\n  \"TagKeys\": []\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-01-01/tags-removal') do |req|
  req.body = "{\n  \"ARN\": \"\",\n  \"TagKeys\": []\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/tags-removal";

    let payload = json!({
        "ARN": "",
        "TagKeys": ()
    });

    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);
}

curl --request POST \
  --url {{baseUrl}}/2015-01-01/tags-removal \
  --header 'content-type: application/json' \
  --data '{
  "ARN": "",
  "TagKeys": []
}'

echo '{
  "ARN": "",
  "TagKeys": []
}' |  \
  http POST {{baseUrl}}/2015-01-01/tags-removal \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ARN": "",\n  "TagKeys": []\n}' \
  --output-document \
  - {{baseUrl}}/2015-01-01/tags-removal

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "ARN": "",
  "TagKeys": []
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/tags-removal")! 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()

POST RevokeVpcEndpointAccess

{{baseUrl}}/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess

QUERY PARAMS

DomainName

BODY json

{
  "Account": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess");

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  \"Account\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess" {:content-type :json
                                                                                                     :form-params {:Account ""}})

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"Account\": \"\"\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-01-01/es/domain/:DomainName/revokeVpcEndpointAccess"),
    Content = new StringContent("{\n  \"Account\": \"\"\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-01-01/es/domain/:DomainName/revokeVpcEndpointAccess");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Account\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess"

	payload := strings.NewReader("{\n  \"Account\": \"\"\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-01-01/es/domain/:DomainName/revokeVpcEndpointAccess HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 19

{
  "Account": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Account\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Account\": \"\"\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  \"Account\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess")
  .header("content-type", "application/json")
  .body("{\n  \"Account\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Account: ''
});

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-01-01/es/domain/:DomainName/revokeVpcEndpointAccess');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess',
  headers: {'content-type': 'application/json'},
  data: {Account: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Account":""}'
};

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-01-01/es/domain/:DomainName/revokeVpcEndpointAccess',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Account": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Account\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess")
  .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-01-01/es/domain/:DomainName/revokeVpcEndpointAccess',
  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({Account: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess',
  headers: {'content-type': 'application/json'},
  body: {Account: ''},
  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-01-01/es/domain/:DomainName/revokeVpcEndpointAccess');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Account: ''
});

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-01-01/es/domain/:DomainName/revokeVpcEndpointAccess',
  headers: {'content-type': 'application/json'},
  data: {Account: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"Account":""}'
};

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 = @{ @"Account": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess"]
                                                       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-01-01/es/domain/:DomainName/revokeVpcEndpointAccess" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"Account\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess",
  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([
    'Account' => ''
  ]),
  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-01-01/es/domain/:DomainName/revokeVpcEndpointAccess', [
  'body' => '{
  "Account": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Account' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Account' => ''
]));
$request->setRequestUrl('{{baseUrl}}/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess');
$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-01-01/es/domain/:DomainName/revokeVpcEndpointAccess' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Account": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Account": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Account\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess"

payload = { "Account": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess"

payload <- "{\n  \"Account\": \"\"\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-01-01/es/domain/:DomainName/revokeVpcEndpointAccess")

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  \"Account\": \"\"\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-01-01/es/domain/:DomainName/revokeVpcEndpointAccess') do |req|
  req.body = "{\n  \"Account\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess";

    let payload = json!({"Account": ""});

    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);
}

curl --request POST \
  --url {{baseUrl}}/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess \
  --header 'content-type: application/json' \
  --data '{
  "Account": ""
}'

echo '{
  "Account": ""
}' |  \
  http POST {{baseUrl}}/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "Account": ""\n}' \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["Account": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/domain/:DomainName/revokeVpcEndpointAccess")! 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()

POST StartElasticsearchServiceSoftwareUpdate

{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/start

BODY json

{
  "DomainName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/start");

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  \"DomainName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/start" {:content-type :json
                                                                                      :form-params {:DomainName ""}})

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/start"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"DomainName\": \"\"\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-01-01/es/serviceSoftwareUpdate/start"),
    Content = new StringContent("{\n  \"DomainName\": \"\"\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-01-01/es/serviceSoftwareUpdate/start");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DomainName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/start"

	payload := strings.NewReader("{\n  \"DomainName\": \"\"\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-01-01/es/serviceSoftwareUpdate/start HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "DomainName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/start")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DomainName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/start"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DomainName\": \"\"\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  \"DomainName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/start")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/start")
  .header("content-type", "application/json")
  .body("{\n  \"DomainName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  DomainName: ''
});

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-01-01/es/serviceSoftwareUpdate/start');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/start',
  headers: {'content-type': 'application/json'},
  data: {DomainName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/start';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DomainName":""}'
};

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-01-01/es/serviceSoftwareUpdate/start',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DomainName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DomainName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/start")
  .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-01-01/es/serviceSoftwareUpdate/start',
  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({DomainName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/start',
  headers: {'content-type': 'application/json'},
  body: {DomainName: ''},
  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-01-01/es/serviceSoftwareUpdate/start');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  DomainName: ''
});

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-01-01/es/serviceSoftwareUpdate/start',
  headers: {'content-type': 'application/json'},
  data: {DomainName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/start';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DomainName":""}'
};

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 = @{ @"DomainName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/start"]
                                                       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-01-01/es/serviceSoftwareUpdate/start" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"DomainName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/start",
  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([
    'DomainName' => ''
  ]),
  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-01-01/es/serviceSoftwareUpdate/start', [
  'body' => '{
  "DomainName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/start');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DomainName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'DomainName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/start');
$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-01-01/es/serviceSoftwareUpdate/start' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DomainName": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/start' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DomainName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"DomainName\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/2015-01-01/es/serviceSoftwareUpdate/start", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/start"

payload = { "DomainName": "" }
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/start"

payload <- "{\n  \"DomainName\": \"\"\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-01-01/es/serviceSoftwareUpdate/start")

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  \"DomainName\": \"\"\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-01-01/es/serviceSoftwareUpdate/start') do |req|
  req.body = "{\n  \"DomainName\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/start";

    let payload = json!({"DomainName": ""});

    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);
}

curl --request POST \
  --url {{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/start \
  --header 'content-type: application/json' \
  --data '{
  "DomainName": ""
}'

echo '{
  "DomainName": ""
}' |  \
  http POST {{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/start \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "DomainName": ""\n}' \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/start

import Foundation

let headers = ["content-type": "application/json"]
let parameters = ["DomainName": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/serviceSoftwareUpdate/start")! 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()

POST UpdateElasticsearchDomainConfig

{{baseUrl}}/2015-01-01/es/domain/:DomainName/config

QUERY PARAMS

DomainName

BODY json

{
  "ElasticsearchClusterConfig": {
    "InstanceType": "",
    "InstanceCount": "",
    "DedicatedMasterEnabled": "",
    "ZoneAwarenessEnabled": "",
    "ZoneAwarenessConfig": "",
    "DedicatedMasterType": "",
    "DedicatedMasterCount": "",
    "WarmEnabled": "",
    "WarmType": "",
    "WarmCount": "",
    "ColdStorageOptions": ""
  },
  "EBSOptions": {
    "EBSEnabled": "",
    "VolumeType": "",
    "VolumeSize": "",
    "Iops": "",
    "Throughput": ""
  },
  "SnapshotOptions": {
    "AutomatedSnapshotStartHour": ""
  },
  "VPCOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  },
  "CognitoOptions": {
    "Enabled": "",
    "UserPoolId": "",
    "IdentityPoolId": "",
    "RoleArn": ""
  },
  "AdvancedOptions": {},
  "AccessPolicies": "",
  "LogPublishingOptions": {},
  "DomainEndpointOptions": {
    "EnforceHTTPS": "",
    "TLSSecurityPolicy": "",
    "CustomEndpointEnabled": "",
    "CustomEndpoint": "",
    "CustomEndpointCertificateArn": ""
  },
  "AdvancedSecurityOptions": {
    "Enabled": "",
    "InternalUserDatabaseEnabled": "",
    "MasterUserOptions": "",
    "SAMLOptions": "",
    "AnonymousAuthEnabled": ""
  },
  "NodeToNodeEncryptionOptions": {
    "Enabled": ""
  },
  "EncryptionAtRestOptions": {
    "Enabled": "",
    "KmsKeyId": ""
  },
  "AutoTuneOptions": {
    "DesiredState": "",
    "RollbackOnDisable": "",
    "MaintenanceSchedules": ""
  },
  "DryRun": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/domain/:DomainName/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  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"AccessPolicies\": \"\",\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"RollbackOnDisable\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"DryRun\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/2015-01-01/es/domain/:DomainName/config" {:content-type :json
                                                                                    :form-params {:ElasticsearchClusterConfig {:InstanceType ""
                                                                                                                               :InstanceCount ""
                                                                                                                               :DedicatedMasterEnabled ""
                                                                                                                               :ZoneAwarenessEnabled ""
                                                                                                                               :ZoneAwarenessConfig ""
                                                                                                                               :DedicatedMasterType ""
                                                                                                                               :DedicatedMasterCount ""
                                                                                                                               :WarmEnabled ""
                                                                                                                               :WarmType ""
                                                                                                                               :WarmCount ""
                                                                                                                               :ColdStorageOptions ""}
                                                                                                  :EBSOptions {:EBSEnabled ""
                                                                                                               :VolumeType ""
                                                                                                               :VolumeSize ""
                                                                                                               :Iops ""
                                                                                                               :Throughput ""}
                                                                                                  :SnapshotOptions {:AutomatedSnapshotStartHour ""}
                                                                                                  :VPCOptions {:SubnetIds ""
                                                                                                               :SecurityGroupIds ""}
                                                                                                  :CognitoOptions {:Enabled ""
                                                                                                                   :UserPoolId ""
                                                                                                                   :IdentityPoolId ""
                                                                                                                   :RoleArn ""}
                                                                                                  :AdvancedOptions {}
                                                                                                  :AccessPolicies ""
                                                                                                  :LogPublishingOptions {}
                                                                                                  :DomainEndpointOptions {:EnforceHTTPS ""
                                                                                                                          :TLSSecurityPolicy ""
                                                                                                                          :CustomEndpointEnabled ""
                                                                                                                          :CustomEndpoint ""
                                                                                                                          :CustomEndpointCertificateArn ""}
                                                                                                  :AdvancedSecurityOptions {:Enabled ""
                                                                                                                            :InternalUserDatabaseEnabled ""
                                                                                                                            :MasterUserOptions ""
                                                                                                                            :SAMLOptions ""
                                                                                                                            :AnonymousAuthEnabled ""}
                                                                                                  :NodeToNodeEncryptionOptions {:Enabled ""}
                                                                                                  :EncryptionAtRestOptions {:Enabled ""
                                                                                                                            :KmsKeyId ""}
                                                                                                  :AutoTuneOptions {:DesiredState ""
                                                                                                                    :RollbackOnDisable ""
                                                                                                                    :MaintenanceSchedules ""}
                                                                                                  :DryRun false}})

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName/config"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"AccessPolicies\": \"\",\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"RollbackOnDisable\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"DryRun\": false\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-01-01/es/domain/:DomainName/config"),
    Content = new StringContent("{\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"AccessPolicies\": \"\",\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"RollbackOnDisable\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"DryRun\": false\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-01-01/es/domain/:DomainName/config");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"AccessPolicies\": \"\",\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"RollbackOnDisable\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"DryRun\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2015-01-01/es/domain/:DomainName/config"

	payload := strings.NewReader("{\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"AccessPolicies\": \"\",\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"RollbackOnDisable\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"DryRun\": false\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-01-01/es/domain/:DomainName/config HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 1421

{
  "ElasticsearchClusterConfig": {
    "InstanceType": "",
    "InstanceCount": "",
    "DedicatedMasterEnabled": "",
    "ZoneAwarenessEnabled": "",
    "ZoneAwarenessConfig": "",
    "DedicatedMasterType": "",
    "DedicatedMasterCount": "",
    "WarmEnabled": "",
    "WarmType": "",
    "WarmCount": "",
    "ColdStorageOptions": ""
  },
  "EBSOptions": {
    "EBSEnabled": "",
    "VolumeType": "",
    "VolumeSize": "",
    "Iops": "",
    "Throughput": ""
  },
  "SnapshotOptions": {
    "AutomatedSnapshotStartHour": ""
  },
  "VPCOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  },
  "CognitoOptions": {
    "Enabled": "",
    "UserPoolId": "",
    "IdentityPoolId": "",
    "RoleArn": ""
  },
  "AdvancedOptions": {},
  "AccessPolicies": "",
  "LogPublishingOptions": {},
  "DomainEndpointOptions": {
    "EnforceHTTPS": "",
    "TLSSecurityPolicy": "",
    "CustomEndpointEnabled": "",
    "CustomEndpoint": "",
    "CustomEndpointCertificateArn": ""
  },
  "AdvancedSecurityOptions": {
    "Enabled": "",
    "InternalUserDatabaseEnabled": "",
    "MasterUserOptions": "",
    "SAMLOptions": "",
    "AnonymousAuthEnabled": ""
  },
  "NodeToNodeEncryptionOptions": {
    "Enabled": ""
  },
  "EncryptionAtRestOptions": {
    "Enabled": "",
    "KmsKeyId": ""
  },
  "AutoTuneOptions": {
    "DesiredState": "",
    "RollbackOnDisable": "",
    "MaintenanceSchedules": ""
  },
  "DryRun": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-01-01/es/domain/:DomainName/config")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"AccessPolicies\": \"\",\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"RollbackOnDisable\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"DryRun\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/domain/:DomainName/config"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"AccessPolicies\": \"\",\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"RollbackOnDisable\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"DryRun\": false\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  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"AccessPolicies\": \"\",\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"RollbackOnDisable\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"DryRun\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/domain/:DomainName/config")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/2015-01-01/es/domain/:DomainName/config")
  .header("content-type", "application/json")
  .body("{\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"AccessPolicies\": \"\",\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"RollbackOnDisable\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"DryRun\": false\n}")
  .asString();

const data = JSON.stringify({
  ElasticsearchClusterConfig: {
    InstanceType: '',
    InstanceCount: '',
    DedicatedMasterEnabled: '',
    ZoneAwarenessEnabled: '',
    ZoneAwarenessConfig: '',
    DedicatedMasterType: '',
    DedicatedMasterCount: '',
    WarmEnabled: '',
    WarmType: '',
    WarmCount: '',
    ColdStorageOptions: ''
  },
  EBSOptions: {
    EBSEnabled: '',
    VolumeType: '',
    VolumeSize: '',
    Iops: '',
    Throughput: ''
  },
  SnapshotOptions: {
    AutomatedSnapshotStartHour: ''
  },
  VPCOptions: {
    SubnetIds: '',
    SecurityGroupIds: ''
  },
  CognitoOptions: {
    Enabled: '',
    UserPoolId: '',
    IdentityPoolId: '',
    RoleArn: ''
  },
  AdvancedOptions: {},
  AccessPolicies: '',
  LogPublishingOptions: {},
  DomainEndpointOptions: {
    EnforceHTTPS: '',
    TLSSecurityPolicy: '',
    CustomEndpointEnabled: '',
    CustomEndpoint: '',
    CustomEndpointCertificateArn: ''
  },
  AdvancedSecurityOptions: {
    Enabled: '',
    InternalUserDatabaseEnabled: '',
    MasterUserOptions: '',
    SAMLOptions: '',
    AnonymousAuthEnabled: ''
  },
  NodeToNodeEncryptionOptions: {
    Enabled: ''
  },
  EncryptionAtRestOptions: {
    Enabled: '',
    KmsKeyId: ''
  },
  AutoTuneOptions: {
    DesiredState: '',
    RollbackOnDisable: '',
    MaintenanceSchedules: ''
  },
  DryRun: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/2015-01-01/es/domain/:DomainName/config');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/domain/:DomainName/config',
  headers: {'content-type': 'application/json'},
  data: {
    ElasticsearchClusterConfig: {
      InstanceType: '',
      InstanceCount: '',
      DedicatedMasterEnabled: '',
      ZoneAwarenessEnabled: '',
      ZoneAwarenessConfig: '',
      DedicatedMasterType: '',
      DedicatedMasterCount: '',
      WarmEnabled: '',
      WarmType: '',
      WarmCount: '',
      ColdStorageOptions: ''
    },
    EBSOptions: {EBSEnabled: '', VolumeType: '', VolumeSize: '', Iops: '', Throughput: ''},
    SnapshotOptions: {AutomatedSnapshotStartHour: ''},
    VPCOptions: {SubnetIds: '', SecurityGroupIds: ''},
    CognitoOptions: {Enabled: '', UserPoolId: '', IdentityPoolId: '', RoleArn: ''},
    AdvancedOptions: {},
    AccessPolicies: '',
    LogPublishingOptions: {},
    DomainEndpointOptions: {
      EnforceHTTPS: '',
      TLSSecurityPolicy: '',
      CustomEndpointEnabled: '',
      CustomEndpoint: '',
      CustomEndpointCertificateArn: ''
    },
    AdvancedSecurityOptions: {
      Enabled: '',
      InternalUserDatabaseEnabled: '',
      MasterUserOptions: '',
      SAMLOptions: '',
      AnonymousAuthEnabled: ''
    },
    NodeToNodeEncryptionOptions: {Enabled: ''},
    EncryptionAtRestOptions: {Enabled: '', KmsKeyId: ''},
    AutoTuneOptions: {DesiredState: '', RollbackOnDisable: '', MaintenanceSchedules: ''},
    DryRun: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2015-01-01/es/domain/:DomainName/config';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ElasticsearchClusterConfig":{"InstanceType":"","InstanceCount":"","DedicatedMasterEnabled":"","ZoneAwarenessEnabled":"","ZoneAwarenessConfig":"","DedicatedMasterType":"","DedicatedMasterCount":"","WarmEnabled":"","WarmType":"","WarmCount":"","ColdStorageOptions":""},"EBSOptions":{"EBSEnabled":"","VolumeType":"","VolumeSize":"","Iops":"","Throughput":""},"SnapshotOptions":{"AutomatedSnapshotStartHour":""},"VPCOptions":{"SubnetIds":"","SecurityGroupIds":""},"CognitoOptions":{"Enabled":"","UserPoolId":"","IdentityPoolId":"","RoleArn":""},"AdvancedOptions":{},"AccessPolicies":"","LogPublishingOptions":{},"DomainEndpointOptions":{"EnforceHTTPS":"","TLSSecurityPolicy":"","CustomEndpointEnabled":"","CustomEndpoint":"","CustomEndpointCertificateArn":""},"AdvancedSecurityOptions":{"Enabled":"","InternalUserDatabaseEnabled":"","MasterUserOptions":"","SAMLOptions":"","AnonymousAuthEnabled":""},"NodeToNodeEncryptionOptions":{"Enabled":""},"EncryptionAtRestOptions":{"Enabled":"","KmsKeyId":""},"AutoTuneOptions":{"DesiredState":"","RollbackOnDisable":"","MaintenanceSchedules":""},"DryRun":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/2015-01-01/es/domain/:DomainName/config',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ElasticsearchClusterConfig": {\n    "InstanceType": "",\n    "InstanceCount": "",\n    "DedicatedMasterEnabled": "",\n    "ZoneAwarenessEnabled": "",\n    "ZoneAwarenessConfig": "",\n    "DedicatedMasterType": "",\n    "DedicatedMasterCount": "",\n    "WarmEnabled": "",\n    "WarmType": "",\n    "WarmCount": "",\n    "ColdStorageOptions": ""\n  },\n  "EBSOptions": {\n    "EBSEnabled": "",\n    "VolumeType": "",\n    "VolumeSize": "",\n    "Iops": "",\n    "Throughput": ""\n  },\n  "SnapshotOptions": {\n    "AutomatedSnapshotStartHour": ""\n  },\n  "VPCOptions": {\n    "SubnetIds": "",\n    "SecurityGroupIds": ""\n  },\n  "CognitoOptions": {\n    "Enabled": "",\n    "UserPoolId": "",\n    "IdentityPoolId": "",\n    "RoleArn": ""\n  },\n  "AdvancedOptions": {},\n  "AccessPolicies": "",\n  "LogPublishingOptions": {},\n  "DomainEndpointOptions": {\n    "EnforceHTTPS": "",\n    "TLSSecurityPolicy": "",\n    "CustomEndpointEnabled": "",\n    "CustomEndpoint": "",\n    "CustomEndpointCertificateArn": ""\n  },\n  "AdvancedSecurityOptions": {\n    "Enabled": "",\n    "InternalUserDatabaseEnabled": "",\n    "MasterUserOptions": "",\n    "SAMLOptions": "",\n    "AnonymousAuthEnabled": ""\n  },\n  "NodeToNodeEncryptionOptions": {\n    "Enabled": ""\n  },\n  "EncryptionAtRestOptions": {\n    "Enabled": "",\n    "KmsKeyId": ""\n  },\n  "AutoTuneOptions": {\n    "DesiredState": "",\n    "RollbackOnDisable": "",\n    "MaintenanceSchedules": ""\n  },\n  "DryRun": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"AccessPolicies\": \"\",\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"RollbackOnDisable\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"DryRun\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/domain/:DomainName/config")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-01-01/es/domain/:DomainName/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({
  ElasticsearchClusterConfig: {
    InstanceType: '',
    InstanceCount: '',
    DedicatedMasterEnabled: '',
    ZoneAwarenessEnabled: '',
    ZoneAwarenessConfig: '',
    DedicatedMasterType: '',
    DedicatedMasterCount: '',
    WarmEnabled: '',
    WarmType: '',
    WarmCount: '',
    ColdStorageOptions: ''
  },
  EBSOptions: {EBSEnabled: '', VolumeType: '', VolumeSize: '', Iops: '', Throughput: ''},
  SnapshotOptions: {AutomatedSnapshotStartHour: ''},
  VPCOptions: {SubnetIds: '', SecurityGroupIds: ''},
  CognitoOptions: {Enabled: '', UserPoolId: '', IdentityPoolId: '', RoleArn: ''},
  AdvancedOptions: {},
  AccessPolicies: '',
  LogPublishingOptions: {},
  DomainEndpointOptions: {
    EnforceHTTPS: '',
    TLSSecurityPolicy: '',
    CustomEndpointEnabled: '',
    CustomEndpoint: '',
    CustomEndpointCertificateArn: ''
  },
  AdvancedSecurityOptions: {
    Enabled: '',
    InternalUserDatabaseEnabled: '',
    MasterUserOptions: '',
    SAMLOptions: '',
    AnonymousAuthEnabled: ''
  },
  NodeToNodeEncryptionOptions: {Enabled: ''},
  EncryptionAtRestOptions: {Enabled: '', KmsKeyId: ''},
  AutoTuneOptions: {DesiredState: '', RollbackOnDisable: '', MaintenanceSchedules: ''},
  DryRun: false
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/domain/:DomainName/config',
  headers: {'content-type': 'application/json'},
  body: {
    ElasticsearchClusterConfig: {
      InstanceType: '',
      InstanceCount: '',
      DedicatedMasterEnabled: '',
      ZoneAwarenessEnabled: '',
      ZoneAwarenessConfig: '',
      DedicatedMasterType: '',
      DedicatedMasterCount: '',
      WarmEnabled: '',
      WarmType: '',
      WarmCount: '',
      ColdStorageOptions: ''
    },
    EBSOptions: {EBSEnabled: '', VolumeType: '', VolumeSize: '', Iops: '', Throughput: ''},
    SnapshotOptions: {AutomatedSnapshotStartHour: ''},
    VPCOptions: {SubnetIds: '', SecurityGroupIds: ''},
    CognitoOptions: {Enabled: '', UserPoolId: '', IdentityPoolId: '', RoleArn: ''},
    AdvancedOptions: {},
    AccessPolicies: '',
    LogPublishingOptions: {},
    DomainEndpointOptions: {
      EnforceHTTPS: '',
      TLSSecurityPolicy: '',
      CustomEndpointEnabled: '',
      CustomEndpoint: '',
      CustomEndpointCertificateArn: ''
    },
    AdvancedSecurityOptions: {
      Enabled: '',
      InternalUserDatabaseEnabled: '',
      MasterUserOptions: '',
      SAMLOptions: '',
      AnonymousAuthEnabled: ''
    },
    NodeToNodeEncryptionOptions: {Enabled: ''},
    EncryptionAtRestOptions: {Enabled: '', KmsKeyId: ''},
    AutoTuneOptions: {DesiredState: '', RollbackOnDisable: '', MaintenanceSchedules: ''},
    DryRun: false
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/2015-01-01/es/domain/:DomainName/config');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ElasticsearchClusterConfig: {
    InstanceType: '',
    InstanceCount: '',
    DedicatedMasterEnabled: '',
    ZoneAwarenessEnabled: '',
    ZoneAwarenessConfig: '',
    DedicatedMasterType: '',
    DedicatedMasterCount: '',
    WarmEnabled: '',
    WarmType: '',
    WarmCount: '',
    ColdStorageOptions: ''
  },
  EBSOptions: {
    EBSEnabled: '',
    VolumeType: '',
    VolumeSize: '',
    Iops: '',
    Throughput: ''
  },
  SnapshotOptions: {
    AutomatedSnapshotStartHour: ''
  },
  VPCOptions: {
    SubnetIds: '',
    SecurityGroupIds: ''
  },
  CognitoOptions: {
    Enabled: '',
    UserPoolId: '',
    IdentityPoolId: '',
    RoleArn: ''
  },
  AdvancedOptions: {},
  AccessPolicies: '',
  LogPublishingOptions: {},
  DomainEndpointOptions: {
    EnforceHTTPS: '',
    TLSSecurityPolicy: '',
    CustomEndpointEnabled: '',
    CustomEndpoint: '',
    CustomEndpointCertificateArn: ''
  },
  AdvancedSecurityOptions: {
    Enabled: '',
    InternalUserDatabaseEnabled: '',
    MasterUserOptions: '',
    SAMLOptions: '',
    AnonymousAuthEnabled: ''
  },
  NodeToNodeEncryptionOptions: {
    Enabled: ''
  },
  EncryptionAtRestOptions: {
    Enabled: '',
    KmsKeyId: ''
  },
  AutoTuneOptions: {
    DesiredState: '',
    RollbackOnDisable: '',
    MaintenanceSchedules: ''
  },
  DryRun: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/domain/:DomainName/config',
  headers: {'content-type': 'application/json'},
  data: {
    ElasticsearchClusterConfig: {
      InstanceType: '',
      InstanceCount: '',
      DedicatedMasterEnabled: '',
      ZoneAwarenessEnabled: '',
      ZoneAwarenessConfig: '',
      DedicatedMasterType: '',
      DedicatedMasterCount: '',
      WarmEnabled: '',
      WarmType: '',
      WarmCount: '',
      ColdStorageOptions: ''
    },
    EBSOptions: {EBSEnabled: '', VolumeType: '', VolumeSize: '', Iops: '', Throughput: ''},
    SnapshotOptions: {AutomatedSnapshotStartHour: ''},
    VPCOptions: {SubnetIds: '', SecurityGroupIds: ''},
    CognitoOptions: {Enabled: '', UserPoolId: '', IdentityPoolId: '', RoleArn: ''},
    AdvancedOptions: {},
    AccessPolicies: '',
    LogPublishingOptions: {},
    DomainEndpointOptions: {
      EnforceHTTPS: '',
      TLSSecurityPolicy: '',
      CustomEndpointEnabled: '',
      CustomEndpoint: '',
      CustomEndpointCertificateArn: ''
    },
    AdvancedSecurityOptions: {
      Enabled: '',
      InternalUserDatabaseEnabled: '',
      MasterUserOptions: '',
      SAMLOptions: '',
      AnonymousAuthEnabled: ''
    },
    NodeToNodeEncryptionOptions: {Enabled: ''},
    EncryptionAtRestOptions: {Enabled: '', KmsKeyId: ''},
    AutoTuneOptions: {DesiredState: '', RollbackOnDisable: '', MaintenanceSchedules: ''},
    DryRun: false
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2015-01-01/es/domain/:DomainName/config';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"ElasticsearchClusterConfig":{"InstanceType":"","InstanceCount":"","DedicatedMasterEnabled":"","ZoneAwarenessEnabled":"","ZoneAwarenessConfig":"","DedicatedMasterType":"","DedicatedMasterCount":"","WarmEnabled":"","WarmType":"","WarmCount":"","ColdStorageOptions":""},"EBSOptions":{"EBSEnabled":"","VolumeType":"","VolumeSize":"","Iops":"","Throughput":""},"SnapshotOptions":{"AutomatedSnapshotStartHour":""},"VPCOptions":{"SubnetIds":"","SecurityGroupIds":""},"CognitoOptions":{"Enabled":"","UserPoolId":"","IdentityPoolId":"","RoleArn":""},"AdvancedOptions":{},"AccessPolicies":"","LogPublishingOptions":{},"DomainEndpointOptions":{"EnforceHTTPS":"","TLSSecurityPolicy":"","CustomEndpointEnabled":"","CustomEndpoint":"","CustomEndpointCertificateArn":""},"AdvancedSecurityOptions":{"Enabled":"","InternalUserDatabaseEnabled":"","MasterUserOptions":"","SAMLOptions":"","AnonymousAuthEnabled":""},"NodeToNodeEncryptionOptions":{"Enabled":""},"EncryptionAtRestOptions":{"Enabled":"","KmsKeyId":""},"AutoTuneOptions":{"DesiredState":"","RollbackOnDisable":"","MaintenanceSchedules":""},"DryRun":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ElasticsearchClusterConfig": @{ @"InstanceType": @"", @"InstanceCount": @"", @"DedicatedMasterEnabled": @"", @"ZoneAwarenessEnabled": @"", @"ZoneAwarenessConfig": @"", @"DedicatedMasterType": @"", @"DedicatedMasterCount": @"", @"WarmEnabled": @"", @"WarmType": @"", @"WarmCount": @"", @"ColdStorageOptions": @"" },
                              @"EBSOptions": @{ @"EBSEnabled": @"", @"VolumeType": @"", @"VolumeSize": @"", @"Iops": @"", @"Throughput": @"" },
                              @"SnapshotOptions": @{ @"AutomatedSnapshotStartHour": @"" },
                              @"VPCOptions": @{ @"SubnetIds": @"", @"SecurityGroupIds": @"" },
                              @"CognitoOptions": @{ @"Enabled": @"", @"UserPoolId": @"", @"IdentityPoolId": @"", @"RoleArn": @"" },
                              @"AdvancedOptions": @{  },
                              @"AccessPolicies": @"",
                              @"LogPublishingOptions": @{  },
                              @"DomainEndpointOptions": @{ @"EnforceHTTPS": @"", @"TLSSecurityPolicy": @"", @"CustomEndpointEnabled": @"", @"CustomEndpoint": @"", @"CustomEndpointCertificateArn": @"" },
                              @"AdvancedSecurityOptions": @{ @"Enabled": @"", @"InternalUserDatabaseEnabled": @"", @"MasterUserOptions": @"", @"SAMLOptions": @"", @"AnonymousAuthEnabled": @"" },
                              @"NodeToNodeEncryptionOptions": @{ @"Enabled": @"" },
                              @"EncryptionAtRestOptions": @{ @"Enabled": @"", @"KmsKeyId": @"" },
                              @"AutoTuneOptions": @{ @"DesiredState": @"", @"RollbackOnDisable": @"", @"MaintenanceSchedules": @"" },
                              @"DryRun": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-01-01/es/domain/:DomainName/config"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/2015-01-01/es/domain/:DomainName/config" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"AccessPolicies\": \"\",\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"RollbackOnDisable\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"DryRun\": false\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2015-01-01/es/domain/:DomainName/config",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'ElasticsearchClusterConfig' => [
        'InstanceType' => '',
        'InstanceCount' => '',
        'DedicatedMasterEnabled' => '',
        'ZoneAwarenessEnabled' => '',
        'ZoneAwarenessConfig' => '',
        'DedicatedMasterType' => '',
        'DedicatedMasterCount' => '',
        'WarmEnabled' => '',
        'WarmType' => '',
        'WarmCount' => '',
        'ColdStorageOptions' => ''
    ],
    'EBSOptions' => [
        'EBSEnabled' => '',
        'VolumeType' => '',
        'VolumeSize' => '',
        'Iops' => '',
        'Throughput' => ''
    ],
    'SnapshotOptions' => [
        'AutomatedSnapshotStartHour' => ''
    ],
    'VPCOptions' => [
        'SubnetIds' => '',
        'SecurityGroupIds' => ''
    ],
    'CognitoOptions' => [
        'Enabled' => '',
        'UserPoolId' => '',
        'IdentityPoolId' => '',
        'RoleArn' => ''
    ],
    'AdvancedOptions' => [
        
    ],
    'AccessPolicies' => '',
    'LogPublishingOptions' => [
        
    ],
    'DomainEndpointOptions' => [
        'EnforceHTTPS' => '',
        'TLSSecurityPolicy' => '',
        'CustomEndpointEnabled' => '',
        'CustomEndpoint' => '',
        'CustomEndpointCertificateArn' => ''
    ],
    'AdvancedSecurityOptions' => [
        'Enabled' => '',
        'InternalUserDatabaseEnabled' => '',
        'MasterUserOptions' => '',
        'SAMLOptions' => '',
        'AnonymousAuthEnabled' => ''
    ],
    'NodeToNodeEncryptionOptions' => [
        'Enabled' => ''
    ],
    'EncryptionAtRestOptions' => [
        'Enabled' => '',
        'KmsKeyId' => ''
    ],
    'AutoTuneOptions' => [
        'DesiredState' => '',
        'RollbackOnDisable' => '',
        'MaintenanceSchedules' => ''
    ],
    'DryRun' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/2015-01-01/es/domain/:DomainName/config', [
  'body' => '{
  "ElasticsearchClusterConfig": {
    "InstanceType": "",
    "InstanceCount": "",
    "DedicatedMasterEnabled": "",
    "ZoneAwarenessEnabled": "",
    "ZoneAwarenessConfig": "",
    "DedicatedMasterType": "",
    "DedicatedMasterCount": "",
    "WarmEnabled": "",
    "WarmType": "",
    "WarmCount": "",
    "ColdStorageOptions": ""
  },
  "EBSOptions": {
    "EBSEnabled": "",
    "VolumeType": "",
    "VolumeSize": "",
    "Iops": "",
    "Throughput": ""
  },
  "SnapshotOptions": {
    "AutomatedSnapshotStartHour": ""
  },
  "VPCOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  },
  "CognitoOptions": {
    "Enabled": "",
    "UserPoolId": "",
    "IdentityPoolId": "",
    "RoleArn": ""
  },
  "AdvancedOptions": {},
  "AccessPolicies": "",
  "LogPublishingOptions": {},
  "DomainEndpointOptions": {
    "EnforceHTTPS": "",
    "TLSSecurityPolicy": "",
    "CustomEndpointEnabled": "",
    "CustomEndpoint": "",
    "CustomEndpointCertificateArn": ""
  },
  "AdvancedSecurityOptions": {
    "Enabled": "",
    "InternalUserDatabaseEnabled": "",
    "MasterUserOptions": "",
    "SAMLOptions": "",
    "AnonymousAuthEnabled": ""
  },
  "NodeToNodeEncryptionOptions": {
    "Enabled": ""
  },
  "EncryptionAtRestOptions": {
    "Enabled": "",
    "KmsKeyId": ""
  },
  "AutoTuneOptions": {
    "DesiredState": "",
    "RollbackOnDisable": "",
    "MaintenanceSchedules": ""
  },
  "DryRun": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/domain/:DomainName/config');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ElasticsearchClusterConfig' => [
    'InstanceType' => '',
    'InstanceCount' => '',
    'DedicatedMasterEnabled' => '',
    'ZoneAwarenessEnabled' => '',
    'ZoneAwarenessConfig' => '',
    'DedicatedMasterType' => '',
    'DedicatedMasterCount' => '',
    'WarmEnabled' => '',
    'WarmType' => '',
    'WarmCount' => '',
    'ColdStorageOptions' => ''
  ],
  'EBSOptions' => [
    'EBSEnabled' => '',
    'VolumeType' => '',
    'VolumeSize' => '',
    'Iops' => '',
    'Throughput' => ''
  ],
  'SnapshotOptions' => [
    'AutomatedSnapshotStartHour' => ''
  ],
  'VPCOptions' => [
    'SubnetIds' => '',
    'SecurityGroupIds' => ''
  ],
  'CognitoOptions' => [
    'Enabled' => '',
    'UserPoolId' => '',
    'IdentityPoolId' => '',
    'RoleArn' => ''
  ],
  'AdvancedOptions' => [
    
  ],
  'AccessPolicies' => '',
  'LogPublishingOptions' => [
    
  ],
  'DomainEndpointOptions' => [
    'EnforceHTTPS' => '',
    'TLSSecurityPolicy' => '',
    'CustomEndpointEnabled' => '',
    'CustomEndpoint' => '',
    'CustomEndpointCertificateArn' => ''
  ],
  'AdvancedSecurityOptions' => [
    'Enabled' => '',
    'InternalUserDatabaseEnabled' => '',
    'MasterUserOptions' => '',
    'SAMLOptions' => '',
    'AnonymousAuthEnabled' => ''
  ],
  'NodeToNodeEncryptionOptions' => [
    'Enabled' => ''
  ],
  'EncryptionAtRestOptions' => [
    'Enabled' => '',
    'KmsKeyId' => ''
  ],
  'AutoTuneOptions' => [
    'DesiredState' => '',
    'RollbackOnDisable' => '',
    'MaintenanceSchedules' => ''
  ],
  'DryRun' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ElasticsearchClusterConfig' => [
    'InstanceType' => '',
    'InstanceCount' => '',
    'DedicatedMasterEnabled' => '',
    'ZoneAwarenessEnabled' => '',
    'ZoneAwarenessConfig' => '',
    'DedicatedMasterType' => '',
    'DedicatedMasterCount' => '',
    'WarmEnabled' => '',
    'WarmType' => '',
    'WarmCount' => '',
    'ColdStorageOptions' => ''
  ],
  'EBSOptions' => [
    'EBSEnabled' => '',
    'VolumeType' => '',
    'VolumeSize' => '',
    'Iops' => '',
    'Throughput' => ''
  ],
  'SnapshotOptions' => [
    'AutomatedSnapshotStartHour' => ''
  ],
  'VPCOptions' => [
    'SubnetIds' => '',
    'SecurityGroupIds' => ''
  ],
  'CognitoOptions' => [
    'Enabled' => '',
    'UserPoolId' => '',
    'IdentityPoolId' => '',
    'RoleArn' => ''
  ],
  'AdvancedOptions' => [
    
  ],
  'AccessPolicies' => '',
  'LogPublishingOptions' => [
    
  ],
  'DomainEndpointOptions' => [
    'EnforceHTTPS' => '',
    'TLSSecurityPolicy' => '',
    'CustomEndpointEnabled' => '',
    'CustomEndpoint' => '',
    'CustomEndpointCertificateArn' => ''
  ],
  'AdvancedSecurityOptions' => [
    'Enabled' => '',
    'InternalUserDatabaseEnabled' => '',
    'MasterUserOptions' => '',
    'SAMLOptions' => '',
    'AnonymousAuthEnabled' => ''
  ],
  'NodeToNodeEncryptionOptions' => [
    'Enabled' => ''
  ],
  'EncryptionAtRestOptions' => [
    'Enabled' => '',
    'KmsKeyId' => ''
  ],
  'AutoTuneOptions' => [
    'DesiredState' => '',
    'RollbackOnDisable' => '',
    'MaintenanceSchedules' => ''
  ],
  'DryRun' => null
]));
$request->setRequestUrl('{{baseUrl}}/2015-01-01/es/domain/:DomainName/config');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/es/domain/:DomainName/config' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ElasticsearchClusterConfig": {
    "InstanceType": "",
    "InstanceCount": "",
    "DedicatedMasterEnabled": "",
    "ZoneAwarenessEnabled": "",
    "ZoneAwarenessConfig": "",
    "DedicatedMasterType": "",
    "DedicatedMasterCount": "",
    "WarmEnabled": "",
    "WarmType": "",
    "WarmCount": "",
    "ColdStorageOptions": ""
  },
  "EBSOptions": {
    "EBSEnabled": "",
    "VolumeType": "",
    "VolumeSize": "",
    "Iops": "",
    "Throughput": ""
  },
  "SnapshotOptions": {
    "AutomatedSnapshotStartHour": ""
  },
  "VPCOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  },
  "CognitoOptions": {
    "Enabled": "",
    "UserPoolId": "",
    "IdentityPoolId": "",
    "RoleArn": ""
  },
  "AdvancedOptions": {},
  "AccessPolicies": "",
  "LogPublishingOptions": {},
  "DomainEndpointOptions": {
    "EnforceHTTPS": "",
    "TLSSecurityPolicy": "",
    "CustomEndpointEnabled": "",
    "CustomEndpoint": "",
    "CustomEndpointCertificateArn": ""
  },
  "AdvancedSecurityOptions": {
    "Enabled": "",
    "InternalUserDatabaseEnabled": "",
    "MasterUserOptions": "",
    "SAMLOptions": "",
    "AnonymousAuthEnabled": ""
  },
  "NodeToNodeEncryptionOptions": {
    "Enabled": ""
  },
  "EncryptionAtRestOptions": {
    "Enabled": "",
    "KmsKeyId": ""
  },
  "AutoTuneOptions": {
    "DesiredState": "",
    "RollbackOnDisable": "",
    "MaintenanceSchedules": ""
  },
  "DryRun": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/domain/:DomainName/config' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ElasticsearchClusterConfig": {
    "InstanceType": "",
    "InstanceCount": "",
    "DedicatedMasterEnabled": "",
    "ZoneAwarenessEnabled": "",
    "ZoneAwarenessConfig": "",
    "DedicatedMasterType": "",
    "DedicatedMasterCount": "",
    "WarmEnabled": "",
    "WarmType": "",
    "WarmCount": "",
    "ColdStorageOptions": ""
  },
  "EBSOptions": {
    "EBSEnabled": "",
    "VolumeType": "",
    "VolumeSize": "",
    "Iops": "",
    "Throughput": ""
  },
  "SnapshotOptions": {
    "AutomatedSnapshotStartHour": ""
  },
  "VPCOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  },
  "CognitoOptions": {
    "Enabled": "",
    "UserPoolId": "",
    "IdentityPoolId": "",
    "RoleArn": ""
  },
  "AdvancedOptions": {},
  "AccessPolicies": "",
  "LogPublishingOptions": {},
  "DomainEndpointOptions": {
    "EnforceHTTPS": "",
    "TLSSecurityPolicy": "",
    "CustomEndpointEnabled": "",
    "CustomEndpoint": "",
    "CustomEndpointCertificateArn": ""
  },
  "AdvancedSecurityOptions": {
    "Enabled": "",
    "InternalUserDatabaseEnabled": "",
    "MasterUserOptions": "",
    "SAMLOptions": "",
    "AnonymousAuthEnabled": ""
  },
  "NodeToNodeEncryptionOptions": {
    "Enabled": ""
  },
  "EncryptionAtRestOptions": {
    "Enabled": "",
    "KmsKeyId": ""
  },
  "AutoTuneOptions": {
    "DesiredState": "",
    "RollbackOnDisable": "",
    "MaintenanceSchedules": ""
  },
  "DryRun": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"AccessPolicies\": \"\",\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"RollbackOnDisable\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"DryRun\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/2015-01-01/es/domain/:DomainName/config", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName/config"

payload = {
    "ElasticsearchClusterConfig": {
        "InstanceType": "",
        "InstanceCount": "",
        "DedicatedMasterEnabled": "",
        "ZoneAwarenessEnabled": "",
        "ZoneAwarenessConfig": "",
        "DedicatedMasterType": "",
        "DedicatedMasterCount": "",
        "WarmEnabled": "",
        "WarmType": "",
        "WarmCount": "",
        "ColdStorageOptions": ""
    },
    "EBSOptions": {
        "EBSEnabled": "",
        "VolumeType": "",
        "VolumeSize": "",
        "Iops": "",
        "Throughput": ""
    },
    "SnapshotOptions": { "AutomatedSnapshotStartHour": "" },
    "VPCOptions": {
        "SubnetIds": "",
        "SecurityGroupIds": ""
    },
    "CognitoOptions": {
        "Enabled": "",
        "UserPoolId": "",
        "IdentityPoolId": "",
        "RoleArn": ""
    },
    "AdvancedOptions": {},
    "AccessPolicies": "",
    "LogPublishingOptions": {},
    "DomainEndpointOptions": {
        "EnforceHTTPS": "",
        "TLSSecurityPolicy": "",
        "CustomEndpointEnabled": "",
        "CustomEndpoint": "",
        "CustomEndpointCertificateArn": ""
    },
    "AdvancedSecurityOptions": {
        "Enabled": "",
        "InternalUserDatabaseEnabled": "",
        "MasterUserOptions": "",
        "SAMLOptions": "",
        "AnonymousAuthEnabled": ""
    },
    "NodeToNodeEncryptionOptions": { "Enabled": "" },
    "EncryptionAtRestOptions": {
        "Enabled": "",
        "KmsKeyId": ""
    },
    "AutoTuneOptions": {
        "DesiredState": "",
        "RollbackOnDisable": "",
        "MaintenanceSchedules": ""
    },
    "DryRun": False
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/domain/:DomainName/config"

payload <- "{\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"AccessPolicies\": \"\",\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"RollbackOnDisable\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"DryRun\": false\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-01-01/es/domain/:DomainName/config")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"AccessPolicies\": \"\",\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"RollbackOnDisable\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"DryRun\": false\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-01-01/es/domain/:DomainName/config') do |req|
  req.body = "{\n  \"ElasticsearchClusterConfig\": {\n    \"InstanceType\": \"\",\n    \"InstanceCount\": \"\",\n    \"DedicatedMasterEnabled\": \"\",\n    \"ZoneAwarenessEnabled\": \"\",\n    \"ZoneAwarenessConfig\": \"\",\n    \"DedicatedMasterType\": \"\",\n    \"DedicatedMasterCount\": \"\",\n    \"WarmEnabled\": \"\",\n    \"WarmType\": \"\",\n    \"WarmCount\": \"\",\n    \"ColdStorageOptions\": \"\"\n  },\n  \"EBSOptions\": {\n    \"EBSEnabled\": \"\",\n    \"VolumeType\": \"\",\n    \"VolumeSize\": \"\",\n    \"Iops\": \"\",\n    \"Throughput\": \"\"\n  },\n  \"SnapshotOptions\": {\n    \"AutomatedSnapshotStartHour\": \"\"\n  },\n  \"VPCOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  },\n  \"CognitoOptions\": {\n    \"Enabled\": \"\",\n    \"UserPoolId\": \"\",\n    \"IdentityPoolId\": \"\",\n    \"RoleArn\": \"\"\n  },\n  \"AdvancedOptions\": {},\n  \"AccessPolicies\": \"\",\n  \"LogPublishingOptions\": {},\n  \"DomainEndpointOptions\": {\n    \"EnforceHTTPS\": \"\",\n    \"TLSSecurityPolicy\": \"\",\n    \"CustomEndpointEnabled\": \"\",\n    \"CustomEndpoint\": \"\",\n    \"CustomEndpointCertificateArn\": \"\"\n  },\n  \"AdvancedSecurityOptions\": {\n    \"Enabled\": \"\",\n    \"InternalUserDatabaseEnabled\": \"\",\n    \"MasterUserOptions\": \"\",\n    \"SAMLOptions\": \"\",\n    \"AnonymousAuthEnabled\": \"\"\n  },\n  \"NodeToNodeEncryptionOptions\": {\n    \"Enabled\": \"\"\n  },\n  \"EncryptionAtRestOptions\": {\n    \"Enabled\": \"\",\n    \"KmsKeyId\": \"\"\n  },\n  \"AutoTuneOptions\": {\n    \"DesiredState\": \"\",\n    \"RollbackOnDisable\": \"\",\n    \"MaintenanceSchedules\": \"\"\n  },\n  \"DryRun\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/domain/:DomainName/config";

    let payload = json!({
        "ElasticsearchClusterConfig": json!({
            "InstanceType": "",
            "InstanceCount": "",
            "DedicatedMasterEnabled": "",
            "ZoneAwarenessEnabled": "",
            "ZoneAwarenessConfig": "",
            "DedicatedMasterType": "",
            "DedicatedMasterCount": "",
            "WarmEnabled": "",
            "WarmType": "",
            "WarmCount": "",
            "ColdStorageOptions": ""
        }),
        "EBSOptions": json!({
            "EBSEnabled": "",
            "VolumeType": "",
            "VolumeSize": "",
            "Iops": "",
            "Throughput": ""
        }),
        "SnapshotOptions": json!({"AutomatedSnapshotStartHour": ""}),
        "VPCOptions": json!({
            "SubnetIds": "",
            "SecurityGroupIds": ""
        }),
        "CognitoOptions": json!({
            "Enabled": "",
            "UserPoolId": "",
            "IdentityPoolId": "",
            "RoleArn": ""
        }),
        "AdvancedOptions": json!({}),
        "AccessPolicies": "",
        "LogPublishingOptions": json!({}),
        "DomainEndpointOptions": json!({
            "EnforceHTTPS": "",
            "TLSSecurityPolicy": "",
            "CustomEndpointEnabled": "",
            "CustomEndpoint": "",
            "CustomEndpointCertificateArn": ""
        }),
        "AdvancedSecurityOptions": json!({
            "Enabled": "",
            "InternalUserDatabaseEnabled": "",
            "MasterUserOptions": "",
            "SAMLOptions": "",
            "AnonymousAuthEnabled": ""
        }),
        "NodeToNodeEncryptionOptions": json!({"Enabled": ""}),
        "EncryptionAtRestOptions": json!({
            "Enabled": "",
            "KmsKeyId": ""
        }),
        "AutoTuneOptions": json!({
            "DesiredState": "",
            "RollbackOnDisable": "",
            "MaintenanceSchedules": ""
        }),
        "DryRun": false
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/2015-01-01/es/domain/:DomainName/config \
  --header 'content-type: application/json' \
  --data '{
  "ElasticsearchClusterConfig": {
    "InstanceType": "",
    "InstanceCount": "",
    "DedicatedMasterEnabled": "",
    "ZoneAwarenessEnabled": "",
    "ZoneAwarenessConfig": "",
    "DedicatedMasterType": "",
    "DedicatedMasterCount": "",
    "WarmEnabled": "",
    "WarmType": "",
    "WarmCount": "",
    "ColdStorageOptions": ""
  },
  "EBSOptions": {
    "EBSEnabled": "",
    "VolumeType": "",
    "VolumeSize": "",
    "Iops": "",
    "Throughput": ""
  },
  "SnapshotOptions": {
    "AutomatedSnapshotStartHour": ""
  },
  "VPCOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  },
  "CognitoOptions": {
    "Enabled": "",
    "UserPoolId": "",
    "IdentityPoolId": "",
    "RoleArn": ""
  },
  "AdvancedOptions": {},
  "AccessPolicies": "",
  "LogPublishingOptions": {},
  "DomainEndpointOptions": {
    "EnforceHTTPS": "",
    "TLSSecurityPolicy": "",
    "CustomEndpointEnabled": "",
    "CustomEndpoint": "",
    "CustomEndpointCertificateArn": ""
  },
  "AdvancedSecurityOptions": {
    "Enabled": "",
    "InternalUserDatabaseEnabled": "",
    "MasterUserOptions": "",
    "SAMLOptions": "",
    "AnonymousAuthEnabled": ""
  },
  "NodeToNodeEncryptionOptions": {
    "Enabled": ""
  },
  "EncryptionAtRestOptions": {
    "Enabled": "",
    "KmsKeyId": ""
  },
  "AutoTuneOptions": {
    "DesiredState": "",
    "RollbackOnDisable": "",
    "MaintenanceSchedules": ""
  },
  "DryRun": false
}'

echo '{
  "ElasticsearchClusterConfig": {
    "InstanceType": "",
    "InstanceCount": "",
    "DedicatedMasterEnabled": "",
    "ZoneAwarenessEnabled": "",
    "ZoneAwarenessConfig": "",
    "DedicatedMasterType": "",
    "DedicatedMasterCount": "",
    "WarmEnabled": "",
    "WarmType": "",
    "WarmCount": "",
    "ColdStorageOptions": ""
  },
  "EBSOptions": {
    "EBSEnabled": "",
    "VolumeType": "",
    "VolumeSize": "",
    "Iops": "",
    "Throughput": ""
  },
  "SnapshotOptions": {
    "AutomatedSnapshotStartHour": ""
  },
  "VPCOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  },
  "CognitoOptions": {
    "Enabled": "",
    "UserPoolId": "",
    "IdentityPoolId": "",
    "RoleArn": ""
  },
  "AdvancedOptions": {},
  "AccessPolicies": "",
  "LogPublishingOptions": {},
  "DomainEndpointOptions": {
    "EnforceHTTPS": "",
    "TLSSecurityPolicy": "",
    "CustomEndpointEnabled": "",
    "CustomEndpoint": "",
    "CustomEndpointCertificateArn": ""
  },
  "AdvancedSecurityOptions": {
    "Enabled": "",
    "InternalUserDatabaseEnabled": "",
    "MasterUserOptions": "",
    "SAMLOptions": "",
    "AnonymousAuthEnabled": ""
  },
  "NodeToNodeEncryptionOptions": {
    "Enabled": ""
  },
  "EncryptionAtRestOptions": {
    "Enabled": "",
    "KmsKeyId": ""
  },
  "AutoTuneOptions": {
    "DesiredState": "",
    "RollbackOnDisable": "",
    "MaintenanceSchedules": ""
  },
  "DryRun": false
}' |  \
  http POST {{baseUrl}}/2015-01-01/es/domain/:DomainName/config \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "ElasticsearchClusterConfig": {\n    "InstanceType": "",\n    "InstanceCount": "",\n    "DedicatedMasterEnabled": "",\n    "ZoneAwarenessEnabled": "",\n    "ZoneAwarenessConfig": "",\n    "DedicatedMasterType": "",\n    "DedicatedMasterCount": "",\n    "WarmEnabled": "",\n    "WarmType": "",\n    "WarmCount": "",\n    "ColdStorageOptions": ""\n  },\n  "EBSOptions": {\n    "EBSEnabled": "",\n    "VolumeType": "",\n    "VolumeSize": "",\n    "Iops": "",\n    "Throughput": ""\n  },\n  "SnapshotOptions": {\n    "AutomatedSnapshotStartHour": ""\n  },\n  "VPCOptions": {\n    "SubnetIds": "",\n    "SecurityGroupIds": ""\n  },\n  "CognitoOptions": {\n    "Enabled": "",\n    "UserPoolId": "",\n    "IdentityPoolId": "",\n    "RoleArn": ""\n  },\n  "AdvancedOptions": {},\n  "AccessPolicies": "",\n  "LogPublishingOptions": {},\n  "DomainEndpointOptions": {\n    "EnforceHTTPS": "",\n    "TLSSecurityPolicy": "",\n    "CustomEndpointEnabled": "",\n    "CustomEndpoint": "",\n    "CustomEndpointCertificateArn": ""\n  },\n  "AdvancedSecurityOptions": {\n    "Enabled": "",\n    "InternalUserDatabaseEnabled": "",\n    "MasterUserOptions": "",\n    "SAMLOptions": "",\n    "AnonymousAuthEnabled": ""\n  },\n  "NodeToNodeEncryptionOptions": {\n    "Enabled": ""\n  },\n  "EncryptionAtRestOptions": {\n    "Enabled": "",\n    "KmsKeyId": ""\n  },\n  "AutoTuneOptions": {\n    "DesiredState": "",\n    "RollbackOnDisable": "",\n    "MaintenanceSchedules": ""\n  },\n  "DryRun": false\n}' \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/domain/:DomainName/config

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "ElasticsearchClusterConfig": [
    "InstanceType": "",
    "InstanceCount": "",
    "DedicatedMasterEnabled": "",
    "ZoneAwarenessEnabled": "",
    "ZoneAwarenessConfig": "",
    "DedicatedMasterType": "",
    "DedicatedMasterCount": "",
    "WarmEnabled": "",
    "WarmType": "",
    "WarmCount": "",
    "ColdStorageOptions": ""
  ],
  "EBSOptions": [
    "EBSEnabled": "",
    "VolumeType": "",
    "VolumeSize": "",
    "Iops": "",
    "Throughput": ""
  ],
  "SnapshotOptions": ["AutomatedSnapshotStartHour": ""],
  "VPCOptions": [
    "SubnetIds": "",
    "SecurityGroupIds": ""
  ],
  "CognitoOptions": [
    "Enabled": "",
    "UserPoolId": "",
    "IdentityPoolId": "",
    "RoleArn": ""
  ],
  "AdvancedOptions": [],
  "AccessPolicies": "",
  "LogPublishingOptions": [],
  "DomainEndpointOptions": [
    "EnforceHTTPS": "",
    "TLSSecurityPolicy": "",
    "CustomEndpointEnabled": "",
    "CustomEndpoint": "",
    "CustomEndpointCertificateArn": ""
  ],
  "AdvancedSecurityOptions": [
    "Enabled": "",
    "InternalUserDatabaseEnabled": "",
    "MasterUserOptions": "",
    "SAMLOptions": "",
    "AnonymousAuthEnabled": ""
  ],
  "NodeToNodeEncryptionOptions": ["Enabled": ""],
  "EncryptionAtRestOptions": [
    "Enabled": "",
    "KmsKeyId": ""
  ],
  "AutoTuneOptions": [
    "DesiredState": "",
    "RollbackOnDisable": "",
    "MaintenanceSchedules": ""
  ],
  "DryRun": false
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/domain/:DomainName/config")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdatePackage

{{baseUrl}}/2015-01-01/packages/update

BODY json

{
  "PackageID": "",
  "PackageSource": {
    "S3BucketName": "",
    "S3Key": ""
  },
  "PackageDescription": "",
  "CommitMessage": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/packages/update");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"PackageID\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\n  },\n  \"PackageDescription\": \"\",\n  \"CommitMessage\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/2015-01-01/packages/update" {:content-type :json
                                                                       :form-params {:PackageID ""
                                                                                     :PackageSource {:S3BucketName ""
                                                                                                     :S3Key ""}
                                                                                     :PackageDescription ""
                                                                                     :CommitMessage ""}})

require "http/client"

url = "{{baseUrl}}/2015-01-01/packages/update"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"PackageID\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\n  },\n  \"PackageDescription\": \"\",\n  \"CommitMessage\": \"\"\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-01-01/packages/update"),
    Content = new StringContent("{\n  \"PackageID\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\n  },\n  \"PackageDescription\": \"\",\n  \"CommitMessage\": \"\"\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-01-01/packages/update");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"PackageID\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\n  },\n  \"PackageDescription\": \"\",\n  \"CommitMessage\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2015-01-01/packages/update"

	payload := strings.NewReader("{\n  \"PackageID\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\n  },\n  \"PackageDescription\": \"\",\n  \"CommitMessage\": \"\"\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-01-01/packages/update HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 138

{
  "PackageID": "",
  "PackageSource": {
    "S3BucketName": "",
    "S3Key": ""
  },
  "PackageDescription": "",
  "CommitMessage": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-01-01/packages/update")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"PackageID\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\n  },\n  \"PackageDescription\": \"\",\n  \"CommitMessage\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/packages/update"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"PackageID\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\n  },\n  \"PackageDescription\": \"\",\n  \"CommitMessage\": \"\"\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  \"PackageID\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\n  },\n  \"PackageDescription\": \"\",\n  \"CommitMessage\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-01-01/packages/update")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/2015-01-01/packages/update")
  .header("content-type", "application/json")
  .body("{\n  \"PackageID\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\n  },\n  \"PackageDescription\": \"\",\n  \"CommitMessage\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  PackageID: '',
  PackageSource: {
    S3BucketName: '',
    S3Key: ''
  },
  PackageDescription: '',
  CommitMessage: ''
});

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-01-01/packages/update');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/packages/update',
  headers: {'content-type': 'application/json'},
  data: {
    PackageID: '',
    PackageSource: {S3BucketName: '', S3Key: ''},
    PackageDescription: '',
    CommitMessage: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2015-01-01/packages/update';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"PackageID":"","PackageSource":{"S3BucketName":"","S3Key":""},"PackageDescription":"","CommitMessage":""}'
};

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-01-01/packages/update',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "PackageID": "",\n  "PackageSource": {\n    "S3BucketName": "",\n    "S3Key": ""\n  },\n  "PackageDescription": "",\n  "CommitMessage": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"PackageID\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\n  },\n  \"PackageDescription\": \"\",\n  \"CommitMessage\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/packages/update")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-01-01/packages/update',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  PackageID: '',
  PackageSource: {S3BucketName: '', S3Key: ''},
  PackageDescription: '',
  CommitMessage: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/packages/update',
  headers: {'content-type': 'application/json'},
  body: {
    PackageID: '',
    PackageSource: {S3BucketName: '', S3Key: ''},
    PackageDescription: '',
    CommitMessage: ''
  },
  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-01-01/packages/update');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  PackageID: '',
  PackageSource: {
    S3BucketName: '',
    S3Key: ''
  },
  PackageDescription: '',
  CommitMessage: ''
});

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-01-01/packages/update',
  headers: {'content-type': 'application/json'},
  data: {
    PackageID: '',
    PackageSource: {S3BucketName: '', S3Key: ''},
    PackageDescription: '',
    CommitMessage: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2015-01-01/packages/update';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"PackageID":"","PackageSource":{"S3BucketName":"","S3Key":""},"PackageDescription":"","CommitMessage":""}'
};

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 = @{ @"PackageID": @"",
                              @"PackageSource": @{ @"S3BucketName": @"", @"S3Key": @"" },
                              @"PackageDescription": @"",
                              @"CommitMessage": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-01-01/packages/update"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/2015-01-01/packages/update" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"PackageID\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\n  },\n  \"PackageDescription\": \"\",\n  \"CommitMessage\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2015-01-01/packages/update",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'PackageID' => '',
    'PackageSource' => [
        'S3BucketName' => '',
        'S3Key' => ''
    ],
    'PackageDescription' => '',
    'CommitMessage' => ''
  ]),
  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-01-01/packages/update', [
  'body' => '{
  "PackageID": "",
  "PackageSource": {
    "S3BucketName": "",
    "S3Key": ""
  },
  "PackageDescription": "",
  "CommitMessage": ""
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/packages/update');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'PackageID' => '',
  'PackageSource' => [
    'S3BucketName' => '',
    'S3Key' => ''
  ],
  'PackageDescription' => '',
  'CommitMessage' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'PackageID' => '',
  'PackageSource' => [
    'S3BucketName' => '',
    'S3Key' => ''
  ],
  'PackageDescription' => '',
  'CommitMessage' => ''
]));
$request->setRequestUrl('{{baseUrl}}/2015-01-01/packages/update');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/packages/update' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PackageID": "",
  "PackageSource": {
    "S3BucketName": "",
    "S3Key": ""
  },
  "PackageDescription": "",
  "CommitMessage": ""
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/packages/update' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PackageID": "",
  "PackageSource": {
    "S3BucketName": "",
    "S3Key": ""
  },
  "PackageDescription": "",
  "CommitMessage": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"PackageID\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\n  },\n  \"PackageDescription\": \"\",\n  \"CommitMessage\": \"\"\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/2015-01-01/packages/update", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2015-01-01/packages/update"

payload = {
    "PackageID": "",
    "PackageSource": {
        "S3BucketName": "",
        "S3Key": ""
    },
    "PackageDescription": "",
    "CommitMessage": ""
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/packages/update"

payload <- "{\n  \"PackageID\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\n  },\n  \"PackageDescription\": \"\",\n  \"CommitMessage\": \"\"\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-01-01/packages/update")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"PackageID\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\n  },\n  \"PackageDescription\": \"\",\n  \"CommitMessage\": \"\"\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-01-01/packages/update') do |req|
  req.body = "{\n  \"PackageID\": \"\",\n  \"PackageSource\": {\n    \"S3BucketName\": \"\",\n    \"S3Key\": \"\"\n  },\n  \"PackageDescription\": \"\",\n  \"CommitMessage\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/packages/update";

    let payload = json!({
        "PackageID": "",
        "PackageSource": json!({
            "S3BucketName": "",
            "S3Key": ""
        }),
        "PackageDescription": "",
        "CommitMessage": ""
    });

    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);
}

curl --request POST \
  --url {{baseUrl}}/2015-01-01/packages/update \
  --header 'content-type: application/json' \
  --data '{
  "PackageID": "",
  "PackageSource": {
    "S3BucketName": "",
    "S3Key": ""
  },
  "PackageDescription": "",
  "CommitMessage": ""
}'

echo '{
  "PackageID": "",
  "PackageSource": {
    "S3BucketName": "",
    "S3Key": ""
  },
  "PackageDescription": "",
  "CommitMessage": ""
}' |  \
  http POST {{baseUrl}}/2015-01-01/packages/update \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "PackageID": "",\n  "PackageSource": {\n    "S3BucketName": "",\n    "S3Key": ""\n  },\n  "PackageDescription": "",\n  "CommitMessage": ""\n}' \
  --output-document \
  - {{baseUrl}}/2015-01-01/packages/update

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "PackageID": "",
  "PackageSource": [
    "S3BucketName": "",
    "S3Key": ""
  ],
  "PackageDescription": "",
  "CommitMessage": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/packages/update")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateVpcEndpoint

{{baseUrl}}/2015-01-01/es/vpcEndpoints/update

BODY json

{
  "VpcEndpointId": "",
  "VpcOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/vpcEndpoints/update");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"VpcEndpointId\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/2015-01-01/es/vpcEndpoints/update" {:content-type :json
                                                                              :form-params {:VpcEndpointId ""
                                                                                            :VpcOptions {:SubnetIds ""
                                                                                                         :SecurityGroupIds ""}}})

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/vpcEndpoints/update"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"VpcEndpointId\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\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-01-01/es/vpcEndpoints/update"),
    Content = new StringContent("{\n  \"VpcEndpointId\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\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-01-01/es/vpcEndpoints/update");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"VpcEndpointId\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2015-01-01/es/vpcEndpoints/update"

	payload := strings.NewReader("{\n  \"VpcEndpointId\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\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-01-01/es/vpcEndpoints/update HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 96

{
  "VpcEndpointId": "",
  "VpcOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-01-01/es/vpcEndpoints/update")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"VpcEndpointId\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/vpcEndpoints/update"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"VpcEndpointId\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\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  \"VpcEndpointId\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/vpcEndpoints/update")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/2015-01-01/es/vpcEndpoints/update")
  .header("content-type", "application/json")
  .body("{\n  \"VpcEndpointId\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  VpcEndpointId: '',
  VpcOptions: {
    SubnetIds: '',
    SecurityGroupIds: ''
  }
});

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-01-01/es/vpcEndpoints/update');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/vpcEndpoints/update',
  headers: {'content-type': 'application/json'},
  data: {VpcEndpointId: '', VpcOptions: {SubnetIds: '', SecurityGroupIds: ''}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2015-01-01/es/vpcEndpoints/update';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"VpcEndpointId":"","VpcOptions":{"SubnetIds":"","SecurityGroupIds":""}}'
};

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-01-01/es/vpcEndpoints/update',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "VpcEndpointId": "",\n  "VpcOptions": {\n    "SubnetIds": "",\n    "SecurityGroupIds": ""\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  \"VpcEndpointId\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/vpcEndpoints/update")
  .post(body)
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/2015-01-01/es/vpcEndpoints/update',
  headers: {
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({VpcEndpointId: '', VpcOptions: {SubnetIds: '', SecurityGroupIds: ''}}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/vpcEndpoints/update',
  headers: {'content-type': 'application/json'},
  body: {VpcEndpointId: '', VpcOptions: {SubnetIds: '', SecurityGroupIds: ''}},
  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-01-01/es/vpcEndpoints/update');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  VpcEndpointId: '',
  VpcOptions: {
    SubnetIds: '',
    SecurityGroupIds: ''
  }
});

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-01-01/es/vpcEndpoints/update',
  headers: {'content-type': 'application/json'},
  data: {VpcEndpointId: '', VpcOptions: {SubnetIds: '', SecurityGroupIds: ''}}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2015-01-01/es/vpcEndpoints/update';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"VpcEndpointId":"","VpcOptions":{"SubnetIds":"","SecurityGroupIds":""}}'
};

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 = @{ @"VpcEndpointId": @"",
                              @"VpcOptions": @{ @"SubnetIds": @"", @"SecurityGroupIds": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-01-01/es/vpcEndpoints/update"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/2015-01-01/es/vpcEndpoints/update" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"VpcEndpointId\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2015-01-01/es/vpcEndpoints/update",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'VpcEndpointId' => '',
    'VpcOptions' => [
        'SubnetIds' => '',
        'SecurityGroupIds' => ''
    ]
  ]),
  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-01-01/es/vpcEndpoints/update', [
  'body' => '{
  "VpcEndpointId": "",
  "VpcOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/vpcEndpoints/update');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'VpcEndpointId' => '',
  'VpcOptions' => [
    'SubnetIds' => '',
    'SecurityGroupIds' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'VpcEndpointId' => '',
  'VpcOptions' => [
    'SubnetIds' => '',
    'SecurityGroupIds' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/2015-01-01/es/vpcEndpoints/update');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/2015-01-01/es/vpcEndpoints/update' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "VpcEndpointId": "",
  "VpcOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  }
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/vpcEndpoints/update' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "VpcEndpointId": "",
  "VpcOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"VpcEndpointId\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\n  }\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/2015-01-01/es/vpcEndpoints/update", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2015-01-01/es/vpcEndpoints/update"

payload = {
    "VpcEndpointId": "",
    "VpcOptions": {
        "SubnetIds": "",
        "SecurityGroupIds": ""
    }
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/vpcEndpoints/update"

payload <- "{\n  \"VpcEndpointId\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\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-01-01/es/vpcEndpoints/update")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/json'
request.body = "{\n  \"VpcEndpointId\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\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-01-01/es/vpcEndpoints/update') do |req|
  req.body = "{\n  \"VpcEndpointId\": \"\",\n  \"VpcOptions\": {\n    \"SubnetIds\": \"\",\n    \"SecurityGroupIds\": \"\"\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-01-01/es/vpcEndpoints/update";

    let payload = json!({
        "VpcEndpointId": "",
        "VpcOptions": json!({
            "SubnetIds": "",
            "SecurityGroupIds": ""
        })
    });

    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);
}

curl --request POST \
  --url {{baseUrl}}/2015-01-01/es/vpcEndpoints/update \
  --header 'content-type: application/json' \
  --data '{
  "VpcEndpointId": "",
  "VpcOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  }
}'

echo '{
  "VpcEndpointId": "",
  "VpcOptions": {
    "SubnetIds": "",
    "SecurityGroupIds": ""
  }
}' |  \
  http POST {{baseUrl}}/2015-01-01/es/vpcEndpoints/update \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "VpcEndpointId": "",\n  "VpcOptions": {\n    "SubnetIds": "",\n    "SecurityGroupIds": ""\n  }\n}' \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/vpcEndpoints/update

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "VpcEndpointId": "",
  "VpcOptions": [
    "SubnetIds": "",
    "SecurityGroupIds": ""
  ]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/vpcEndpoints/update")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpgradeElasticsearchDomain

{{baseUrl}}/2015-01-01/es/upgradeDomain

BODY json

{
  "DomainName": "",
  "TargetVersion": "",
  "PerformCheckOnly": false
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/2015-01-01/es/upgradeDomain");

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  \"DomainName\": \"\",\n  \"TargetVersion\": \"\",\n  \"PerformCheckOnly\": false\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/2015-01-01/es/upgradeDomain" {:content-type :json
                                                                        :form-params {:DomainName ""
                                                                                      :TargetVersion ""
                                                                                      :PerformCheckOnly false}})

require "http/client"

url = "{{baseUrl}}/2015-01-01/es/upgradeDomain"
headers = HTTP::Headers{
  "content-type" => "application/json"
}
reqBody = "{\n  \"DomainName\": \"\",\n  \"TargetVersion\": \"\",\n  \"PerformCheckOnly\": false\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-01-01/es/upgradeDomain"),
    Content = new StringContent("{\n  \"DomainName\": \"\",\n  \"TargetVersion\": \"\",\n  \"PerformCheckOnly\": false\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-01-01/es/upgradeDomain");
var request = new RestRequest("", Method.Post);
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DomainName\": \"\",\n  \"TargetVersion\": \"\",\n  \"PerformCheckOnly\": false\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/2015-01-01/es/upgradeDomain"

	payload := strings.NewReader("{\n  \"DomainName\": \"\",\n  \"TargetVersion\": \"\",\n  \"PerformCheckOnly\": false\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-01-01/es/upgradeDomain HTTP/1.1
Content-Type: application/json
Host: example.com
Content-Length: 74

{
  "DomainName": "",
  "TargetVersion": "",
  "PerformCheckOnly": false
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/2015-01-01/es/upgradeDomain")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DomainName\": \"\",\n  \"TargetVersion\": \"\",\n  \"PerformCheckOnly\": false\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/2015-01-01/es/upgradeDomain"))
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DomainName\": \"\",\n  \"TargetVersion\": \"\",\n  \"PerformCheckOnly\": false\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  \"DomainName\": \"\",\n  \"TargetVersion\": \"\",\n  \"PerformCheckOnly\": false\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/upgradeDomain")
  .post(body)
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/2015-01-01/es/upgradeDomain")
  .header("content-type", "application/json")
  .body("{\n  \"DomainName\": \"\",\n  \"TargetVersion\": \"\",\n  \"PerformCheckOnly\": false\n}")
  .asString();

const data = JSON.stringify({
  DomainName: '',
  TargetVersion: '',
  PerformCheckOnly: false
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/2015-01-01/es/upgradeDomain');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/upgradeDomain',
  headers: {'content-type': 'application/json'},
  data: {DomainName: '', TargetVersion: '', PerformCheckOnly: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/2015-01-01/es/upgradeDomain';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DomainName":"","TargetVersion":"","PerformCheckOnly":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/2015-01-01/es/upgradeDomain',
  method: 'POST',
  headers: {
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DomainName": "",\n  "TargetVersion": "",\n  "PerformCheckOnly": false\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DomainName\": \"\",\n  \"TargetVersion\": \"\",\n  \"PerformCheckOnly\": false\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/2015-01-01/es/upgradeDomain")
  .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-01-01/es/upgradeDomain',
  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({DomainName: '', TargetVersion: '', PerformCheckOnly: false}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/upgradeDomain',
  headers: {'content-type': 'application/json'},
  body: {DomainName: '', TargetVersion: '', PerformCheckOnly: false},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/2015-01-01/es/upgradeDomain');

req.headers({
  'content-type': 'application/json'
});

req.type('json');
req.send({
  DomainName: '',
  TargetVersion: '',
  PerformCheckOnly: false
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/2015-01-01/es/upgradeDomain',
  headers: {'content-type': 'application/json'},
  data: {DomainName: '', TargetVersion: '', PerformCheckOnly: false}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/2015-01-01/es/upgradeDomain';
const options = {
  method: 'POST',
  headers: {'content-type': 'application/json'},
  body: '{"DomainName":"","TargetVersion":"","PerformCheckOnly":false}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"DomainName": @"",
                              @"TargetVersion": @"",
                              @"PerformCheckOnly": @NO };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/2015-01-01/es/upgradeDomain"]
                                                       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-01-01/es/upgradeDomain" in
let headers = Header.add (Header.init ()) "content-type" "application/json" in
let body = Cohttp_lwt_body.of_string "{\n  \"DomainName\": \"\",\n  \"TargetVersion\": \"\",\n  \"PerformCheckOnly\": false\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/2015-01-01/es/upgradeDomain",
  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([
    'DomainName' => '',
    'TargetVersion' => '',
    'PerformCheckOnly' => null
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/2015-01-01/es/upgradeDomain', [
  'body' => '{
  "DomainName": "",
  "TargetVersion": "",
  "PerformCheckOnly": false
}',
  'headers' => [
    'content-type' => 'application/json',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/2015-01-01/es/upgradeDomain');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DomainName' => '',
  'TargetVersion' => '',
  'PerformCheckOnly' => null
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'DomainName' => '',
  'TargetVersion' => '',
  'PerformCheckOnly' => null
]));
$request->setRequestUrl('{{baseUrl}}/2015-01-01/es/upgradeDomain');
$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-01-01/es/upgradeDomain' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DomainName": "",
  "TargetVersion": "",
  "PerformCheckOnly": false
}'

$headers=@{}
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/2015-01-01/es/upgradeDomain' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DomainName": "",
  "TargetVersion": "",
  "PerformCheckOnly": false
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"DomainName\": \"\",\n  \"TargetVersion\": \"\",\n  \"PerformCheckOnly\": false\n}"

headers = { 'content-type': "application/json" }

conn.request("POST", "/baseUrl/2015-01-01/es/upgradeDomain", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/2015-01-01/es/upgradeDomain"

payload = {
    "DomainName": "",
    "TargetVersion": "",
    "PerformCheckOnly": False
}
headers = {"content-type": "application/json"}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/2015-01-01/es/upgradeDomain"

payload <- "{\n  \"DomainName\": \"\",\n  \"TargetVersion\": \"\",\n  \"PerformCheckOnly\": false\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-01-01/es/upgradeDomain")

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  \"DomainName\": \"\",\n  \"TargetVersion\": \"\",\n  \"PerformCheckOnly\": false\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-01-01/es/upgradeDomain') do |req|
  req.body = "{\n  \"DomainName\": \"\",\n  \"TargetVersion\": \"\",\n  \"PerformCheckOnly\": false\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/2015-01-01/es/upgradeDomain";

    let payload = json!({
        "DomainName": "",
        "TargetVersion": "",
        "PerformCheckOnly": false
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url {{baseUrl}}/2015-01-01/es/upgradeDomain \
  --header 'content-type: application/json' \
  --data '{
  "DomainName": "",
  "TargetVersion": "",
  "PerformCheckOnly": false
}'

echo '{
  "DomainName": "",
  "TargetVersion": "",
  "PerformCheckOnly": false
}' |  \
  http POST {{baseUrl}}/2015-01-01/es/upgradeDomain \
  content-type:application/json

wget --quiet \
  --method POST \
  --header 'content-type: application/json' \
  --body-data '{\n  "DomainName": "",\n  "TargetVersion": "",\n  "PerformCheckOnly": false\n}' \
  --output-document \
  - {{baseUrl}}/2015-01-01/es/upgradeDomain

import Foundation

let headers = ["content-type": "application/json"]
let parameters = [
  "DomainName": "",
  "TargetVersion": "",
  "PerformCheckOnly": false
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/2015-01-01/es/upgradeDomain")! 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()