AWS Storage Gateway

POST ActivateGateway

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway

HEADERS

X-Amz-Target

BODY json

{
  "ActivationKey": "",
  "GatewayName": "",
  "GatewayTimezone": "",
  "GatewayRegion": "",
  "GatewayType": "",
  "TapeDriveType": "",
  "MediumChangerType": "",
  "Tags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ActivationKey\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"GatewayRegion\": \"\",\n  \"GatewayType\": \"\",\n  \"TapeDriveType\": \"\",\n  \"MediumChangerType\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:ActivationKey ""
                                                                                                                :GatewayName ""
                                                                                                                :GatewayTimezone ""
                                                                                                                :GatewayRegion ""
                                                                                                                :GatewayType ""
                                                                                                                :TapeDriveType ""
                                                                                                                :MediumChangerType ""
                                                                                                                :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ActivationKey\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"GatewayRegion\": \"\",\n  \"GatewayType\": \"\",\n  \"TapeDriveType\": \"\",\n  \"MediumChangerType\": \"\",\n  \"Tags\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ActivationKey\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"GatewayRegion\": \"\",\n  \"GatewayType\": \"\",\n  \"TapeDriveType\": \"\",\n  \"MediumChangerType\": \"\",\n  \"Tags\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ActivationKey\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"GatewayRegion\": \"\",\n  \"GatewayType\": \"\",\n  \"TapeDriveType\": \"\",\n  \"MediumChangerType\": \"\",\n  \"Tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway"

	payload := strings.NewReader("{\n  \"ActivationKey\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"GatewayRegion\": \"\",\n  \"GatewayType\": \"\",\n  \"TapeDriveType\": \"\",\n  \"MediumChangerType\": \"\",\n  \"Tags\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 179

{
  "ActivationKey": "",
  "GatewayName": "",
  "GatewayTimezone": "",
  "GatewayRegion": "",
  "GatewayType": "",
  "TapeDriveType": "",
  "MediumChangerType": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ActivationKey\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"GatewayRegion\": \"\",\n  \"GatewayType\": \"\",\n  \"TapeDriveType\": \"\",\n  \"MediumChangerType\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ActivationKey\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"GatewayRegion\": \"\",\n  \"GatewayType\": \"\",\n  \"TapeDriveType\": \"\",\n  \"MediumChangerType\": \"\",\n  \"Tags\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ActivationKey\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"GatewayRegion\": \"\",\n  \"GatewayType\": \"\",\n  \"TapeDriveType\": \"\",\n  \"MediumChangerType\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ActivationKey\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"GatewayRegion\": \"\",\n  \"GatewayType\": \"\",\n  \"TapeDriveType\": \"\",\n  \"MediumChangerType\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ActivationKey: '',
  GatewayName: '',
  GatewayTimezone: '',
  GatewayRegion: '',
  GatewayType: '',
  TapeDriveType: '',
  MediumChangerType: '',
  Tags: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ActivationKey: '',
    GatewayName: '',
    GatewayTimezone: '',
    GatewayRegion: '',
    GatewayType: '',
    TapeDriveType: '',
    MediumChangerType: '',
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ActivationKey":"","GatewayName":"","GatewayTimezone":"","GatewayRegion":"","GatewayType":"","TapeDriveType":"","MediumChangerType":"","Tags":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ActivationKey": "",\n  "GatewayName": "",\n  "GatewayTimezone": "",\n  "GatewayRegion": "",\n  "GatewayType": "",\n  "TapeDriveType": "",\n  "MediumChangerType": "",\n  "Tags": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ActivationKey\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"GatewayRegion\": \"\",\n  \"GatewayType\": \"\",\n  \"TapeDriveType\": \"\",\n  \"MediumChangerType\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({
  ActivationKey: '',
  GatewayName: '',
  GatewayTimezone: '',
  GatewayRegion: '',
  GatewayType: '',
  TapeDriveType: '',
  MediumChangerType: '',
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ActivationKey: '',
    GatewayName: '',
    GatewayTimezone: '',
    GatewayRegion: '',
    GatewayType: '',
    TapeDriveType: '',
    MediumChangerType: '',
    Tags: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway');

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

req.type('json');
req.send({
  ActivationKey: '',
  GatewayName: '',
  GatewayTimezone: '',
  GatewayRegion: '',
  GatewayType: '',
  TapeDriveType: '',
  MediumChangerType: '',
  Tags: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ActivationKey: '',
    GatewayName: '',
    GatewayTimezone: '',
    GatewayRegion: '',
    GatewayType: '',
    TapeDriveType: '',
    MediumChangerType: '',
    Tags: ''
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ActivationKey":"","GatewayName":"","GatewayTimezone":"","GatewayRegion":"","GatewayType":"","TapeDriveType":"","MediumChangerType":"","Tags":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ActivationKey": @"",
                              @"GatewayName": @"",
                              @"GatewayTimezone": @"",
                              @"GatewayRegion": @"",
                              @"GatewayType": @"",
                              @"TapeDriveType": @"",
                              @"MediumChangerType": @"",
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ActivationKey\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"GatewayRegion\": \"\",\n  \"GatewayType\": \"\",\n  \"TapeDriveType\": \"\",\n  \"MediumChangerType\": \"\",\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway",
  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([
    'ActivationKey' => '',
    'GatewayName' => '',
    'GatewayTimezone' => '',
    'GatewayRegion' => '',
    'GatewayType' => '',
    'TapeDriveType' => '',
    'MediumChangerType' => '',
    'Tags' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway', [
  'body' => '{
  "ActivationKey": "",
  "GatewayName": "",
  "GatewayTimezone": "",
  "GatewayRegion": "",
  "GatewayType": "",
  "TapeDriveType": "",
  "MediumChangerType": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ActivationKey' => '',
  'GatewayName' => '',
  'GatewayTimezone' => '',
  'GatewayRegion' => '',
  'GatewayType' => '',
  'TapeDriveType' => '',
  'MediumChangerType' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'ActivationKey' => '',
  'GatewayName' => '',
  'GatewayTimezone' => '',
  'GatewayRegion' => '',
  'GatewayType' => '',
  'TapeDriveType' => '',
  'MediumChangerType' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ActivationKey": "",
  "GatewayName": "",
  "GatewayTimezone": "",
  "GatewayRegion": "",
  "GatewayType": "",
  "TapeDriveType": "",
  "MediumChangerType": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ActivationKey": "",
  "GatewayName": "",
  "GatewayTimezone": "",
  "GatewayRegion": "",
  "GatewayType": "",
  "TapeDriveType": "",
  "MediumChangerType": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"ActivationKey\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"GatewayRegion\": \"\",\n  \"GatewayType\": \"\",\n  \"TapeDriveType\": \"\",\n  \"MediumChangerType\": \"\",\n  \"Tags\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway"

payload = {
    "ActivationKey": "",
    "GatewayName": "",
    "GatewayTimezone": "",
    "GatewayRegion": "",
    "GatewayType": "",
    "TapeDriveType": "",
    "MediumChangerType": "",
    "Tags": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway"

payload <- "{\n  \"ActivationKey\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"GatewayRegion\": \"\",\n  \"GatewayType\": \"\",\n  \"TapeDriveType\": \"\",\n  \"MediumChangerType\": \"\",\n  \"Tags\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"ActivationKey\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"GatewayRegion\": \"\",\n  \"GatewayType\": \"\",\n  \"TapeDriveType\": \"\",\n  \"MediumChangerType\": \"\",\n  \"Tags\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"ActivationKey\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"GatewayRegion\": \"\",\n  \"GatewayType\": \"\",\n  \"TapeDriveType\": \"\",\n  \"MediumChangerType\": \"\",\n  \"Tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway";

    let payload = json!({
        "ActivationKey": "",
        "GatewayName": "",
        "GatewayTimezone": "",
        "GatewayRegion": "",
        "GatewayType": "",
        "TapeDriveType": "",
        "MediumChangerType": "",
        "Tags": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ActivationKey": "",
  "GatewayName": "",
  "GatewayTimezone": "",
  "GatewayRegion": "",
  "GatewayType": "",
  "TapeDriveType": "",
  "MediumChangerType": "",
  "Tags": ""
}'

echo '{
  "ActivationKey": "",
  "GatewayName": "",
  "GatewayTimezone": "",
  "GatewayRegion": "",
  "GatewayType": "",
  "TapeDriveType": "",
  "MediumChangerType": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ActivationKey": "",\n  "GatewayName": "",\n  "GatewayTimezone": "",\n  "GatewayRegion": "",\n  "GatewayType": "",\n  "TapeDriveType": "",\n  "MediumChangerType": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ActivationKey": "",
  "GatewayName": "",
  "GatewayTimezone": "",
  "GatewayRegion": "",
  "GatewayType": "",
  "TapeDriveType": "",
  "MediumChangerType": "",
  "Tags": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ActivateGateway")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "GatewayARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-11A2222B"
}

POST AddCache

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "DiskIds": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache" {:headers {:x-amz-target ""}
                                                                                           :content-type :json
                                                                                           :form-params {:GatewayARN ""
                                                                                                         :DiskIds ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.AddCache"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.AddCache");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 39

{
  "GatewayARN": "",
  "DiskIds": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\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  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  DiskIds: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', DiskIds: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","DiskIds":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.AddCache',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "DiskIds": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: '', DiskIds: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: '', DiskIds: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.AddCache');

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

req.type('json');
req.send({
  GatewayARN: '',
  DiskIds: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.AddCache',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', DiskIds: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","DiskIds":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"DiskIds": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.AddCache" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache",
  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([
    'GatewayARN' => '',
    'DiskIds' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache', [
  'body' => '{
  "GatewayARN": "",
  "DiskIds": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'GatewayARN' => '',
  'DiskIds' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "DiskIds": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "DiskIds": ""
}'

import http.client

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

payload = "{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache"

payload = {
    "GatewayARN": "",
    "DiskIds": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache";

    let payload = json!({
        "GatewayARN": "",
        "DiskIds": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.AddCache' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "DiskIds": ""
}'

echo '{
  "GatewayARN": "",
  "DiskIds": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "DiskIds": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "DiskIds": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddCache")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "GatewayARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B"
}

POST AddTagsToResource

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource

HEADERS

X-Amz-Target

BODY json

{
  "ResourceARN": "",
  "Tags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:ResourceARN ""
                                                                                                                  :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ResourceARN\": \"\",\n  \"Tags\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ResourceARN\": \"\",\n  \"Tags\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ResourceARN\": \"\",\n  \"Tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource"

	payload := strings.NewReader("{\n  \"ResourceARN\": \"\",\n  \"Tags\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 37

{
  "ResourceARN": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ResourceARN\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ResourceARN\": \"\",\n  \"Tags\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ResourceARN\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ResourceARN\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ResourceARN: '',
  Tags: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceARN: '', Tags: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceARN":"","Tags":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResourceARN": "",\n  "Tags": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ResourceARN\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({ResourceARN: '', Tags: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ResourceARN: '', Tags: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource');

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

req.type('json');
req.send({
  ResourceARN: '',
  Tags: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceARN: '', Tags: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceARN":"","Tags":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ResourceARN": @"",
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ResourceARN\": \"\",\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource",
  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([
    'ResourceARN' => '',
    'Tags' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource', [
  'body' => '{
  "ResourceARN": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'ResourceARN' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceARN": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceARN": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"ResourceARN\": \"\",\n  \"Tags\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource"

payload = {
    "ResourceARN": "",
    "Tags": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource"

payload <- "{\n  \"ResourceARN\": \"\",\n  \"Tags\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"ResourceARN\": \"\",\n  \"Tags\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"ResourceARN\": \"\",\n  \"Tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource";

    let payload = json!({
        "ResourceARN": "",
        "Tags": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceARN": "",
  "Tags": ""
}'

echo '{
  "ResourceARN": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ResourceARN": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ResourceARN": "",
  "Tags": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddTagsToResource")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "ResourceARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-11A2222B"
}

POST AddUploadBuffer

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "DiskIds": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:GatewayARN ""
                                                                                                                :DiskIds ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 39

{
  "GatewayARN": "",
  "DiskIds": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\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  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  DiskIds: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', DiskIds: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","DiskIds":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "DiskIds": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: '', DiskIds: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: '', DiskIds: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer');

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

req.type('json');
req.send({
  GatewayARN: '',
  DiskIds: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', DiskIds: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","DiskIds":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"DiskIds": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer",
  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([
    'GatewayARN' => '',
    'DiskIds' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer', [
  'body' => '{
  "GatewayARN": "",
  "DiskIds": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'GatewayARN' => '',
  'DiskIds' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "DiskIds": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "DiskIds": ""
}'

import http.client

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

payload = "{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer"

payload = {
    "GatewayARN": "",
    "DiskIds": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer";

    let payload = json!({
        "GatewayARN": "",
        "DiskIds": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "DiskIds": ""
}'

echo '{
  "GatewayARN": "",
  "DiskIds": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "DiskIds": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "DiskIds": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddUploadBuffer")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "GatewayARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B"
}

POST AddWorkingStorage

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "DiskIds": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:GatewayARN ""
                                                                                                                  :DiskIds ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 39

{
  "GatewayARN": "",
  "DiskIds": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\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  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  DiskIds: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', DiskIds: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","DiskIds":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "DiskIds": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: '', DiskIds: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: '', DiskIds: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage');

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

req.type('json');
req.send({
  GatewayARN: '',
  DiskIds: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', DiskIds: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","DiskIds":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"DiskIds": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage",
  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([
    'GatewayARN' => '',
    'DiskIds' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage', [
  'body' => '{
  "GatewayARN": "",
  "DiskIds": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'GatewayARN' => '',
  'DiskIds' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "DiskIds": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "DiskIds": ""
}'

import http.client

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

payload = "{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage"

payload = {
    "GatewayARN": "",
    "DiskIds": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"DiskIds\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage";

    let payload = json!({
        "GatewayARN": "",
        "DiskIds": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "DiskIds": ""
}'

echo '{
  "GatewayARN": "",
  "DiskIds": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "DiskIds": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "DiskIds": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AddWorkingStorage")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "GatewayARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B"
}

POST AssignTapePool

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool

HEADERS

X-Amz-Target

BODY json

{
  "TapeARN": "",
  "PoolId": "",
  "BypassGovernanceRetention": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"TapeARN\": \"\",\n  \"PoolId\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool" {:headers {:x-amz-target ""}
                                                                                                 :content-type :json
                                                                                                 :form-params {:TapeARN ""
                                                                                                               :PoolId ""
                                                                                                               :BypassGovernanceRetention ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TapeARN\": \"\",\n  \"PoolId\": \"\",\n  \"BypassGovernanceRetention\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TapeARN\": \"\",\n  \"PoolId\": \"\",\n  \"BypassGovernanceRetention\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TapeARN\": \"\",\n  \"PoolId\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool"

	payload := strings.NewReader("{\n  \"TapeARN\": \"\",\n  \"PoolId\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 70

{
  "TapeARN": "",
  "PoolId": "",
  "BypassGovernanceRetention": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TapeARN\": \"\",\n  \"PoolId\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TapeARN\": \"\",\n  \"PoolId\": \"\",\n  \"BypassGovernanceRetention\": \"\"\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  \"TapeARN\": \"\",\n  \"PoolId\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TapeARN\": \"\",\n  \"PoolId\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TapeARN: '',
  PoolId: '',
  BypassGovernanceRetention: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TapeARN: '', PoolId: '', BypassGovernanceRetention: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TapeARN":"","PoolId":"","BypassGovernanceRetention":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TapeARN": "",\n  "PoolId": "",\n  "BypassGovernanceRetention": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TapeARN\": \"\",\n  \"PoolId\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({TapeARN: '', PoolId: '', BypassGovernanceRetention: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {TapeARN: '', PoolId: '', BypassGovernanceRetention: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool');

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

req.type('json');
req.send({
  TapeARN: '',
  PoolId: '',
  BypassGovernanceRetention: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TapeARN: '', PoolId: '', BypassGovernanceRetention: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TapeARN":"","PoolId":"","BypassGovernanceRetention":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"TapeARN": @"",
                              @"PoolId": @"",
                              @"BypassGovernanceRetention": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TapeARN\": \"\",\n  \"PoolId\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool",
  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([
    'TapeARN' => '',
    'PoolId' => '',
    'BypassGovernanceRetention' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool', [
  'body' => '{
  "TapeARN": "",
  "PoolId": "",
  "BypassGovernanceRetention": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TapeARN' => '',
  'PoolId' => '',
  'BypassGovernanceRetention' => ''
]));

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

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

append(json_encode([
  'TapeARN' => '',
  'PoolId' => '',
  'BypassGovernanceRetention' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TapeARN": "",
  "PoolId": "",
  "BypassGovernanceRetention": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TapeARN": "",
  "PoolId": "",
  "BypassGovernanceRetention": ""
}'

import http.client

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

payload = "{\n  \"TapeARN\": \"\",\n  \"PoolId\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool"

payload = {
    "TapeARN": "",
    "PoolId": "",
    "BypassGovernanceRetention": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool"

payload <- "{\n  \"TapeARN\": \"\",\n  \"PoolId\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"TapeARN\": \"\",\n  \"PoolId\": \"\",\n  \"BypassGovernanceRetention\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"TapeARN\": \"\",\n  \"PoolId\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool";

    let payload = json!({
        "TapeARN": "",
        "PoolId": "",
        "BypassGovernanceRetention": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "TapeARN": "",
  "PoolId": "",
  "BypassGovernanceRetention": ""
}'

echo '{
  "TapeARN": "",
  "PoolId": "",
  "BypassGovernanceRetention": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TapeARN": "",\n  "PoolId": "",\n  "BypassGovernanceRetention": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TapeARN": "",
  "PoolId": "",
  "BypassGovernanceRetention": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssignTapePool")! 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 AssociateFileSystem

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem

HEADERS

X-Amz-Target

BODY json

{
  "UserName": "",
  "Password": "",
  "ClientToken": "",
  "GatewayARN": "",
  "LocationARN": "",
  "Tags": "",
  "AuditDestinationARN": "",
  "CacheAttributes": {
    "CacheStaleTimeoutInSeconds": ""
  },
  "EndpointNetworkConfiguration": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"LocationARN\": \"\",\n  \"Tags\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\n  },\n  \"EndpointNetworkConfiguration\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:UserName ""
                                                                                                                    :Password ""
                                                                                                                    :ClientToken ""
                                                                                                                    :GatewayARN ""
                                                                                                                    :LocationARN ""
                                                                                                                    :Tags ""
                                                                                                                    :AuditDestinationARN ""
                                                                                                                    :CacheAttributes {:CacheStaleTimeoutInSeconds ""}
                                                                                                                    :EndpointNetworkConfiguration ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"LocationARN\": \"\",\n  \"Tags\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\n  },\n  \"EndpointNetworkConfiguration\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"LocationARN\": \"\",\n  \"Tags\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\n  },\n  \"EndpointNetworkConfiguration\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"LocationARN\": \"\",\n  \"Tags\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\n  },\n  \"EndpointNetworkConfiguration\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem"

	payload := strings.NewReader("{\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"LocationARN\": \"\",\n  \"Tags\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\n  },\n  \"EndpointNetworkConfiguration\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 246

{
  "UserName": "",
  "Password": "",
  "ClientToken": "",
  "GatewayARN": "",
  "LocationARN": "",
  "Tags": "",
  "AuditDestinationARN": "",
  "CacheAttributes": {
    "CacheStaleTimeoutInSeconds": ""
  },
  "EndpointNetworkConfiguration": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"LocationARN\": \"\",\n  \"Tags\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\n  },\n  \"EndpointNetworkConfiguration\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"LocationARN\": \"\",\n  \"Tags\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\n  },\n  \"EndpointNetworkConfiguration\": \"\"\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  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"LocationARN\": \"\",\n  \"Tags\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\n  },\n  \"EndpointNetworkConfiguration\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"LocationARN\": \"\",\n  \"Tags\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\n  },\n  \"EndpointNetworkConfiguration\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  UserName: '',
  Password: '',
  ClientToken: '',
  GatewayARN: '',
  LocationARN: '',
  Tags: '',
  AuditDestinationARN: '',
  CacheAttributes: {
    CacheStaleTimeoutInSeconds: ''
  },
  EndpointNetworkConfiguration: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserName: '',
    Password: '',
    ClientToken: '',
    GatewayARN: '',
    LocationARN: '',
    Tags: '',
    AuditDestinationARN: '',
    CacheAttributes: {CacheStaleTimeoutInSeconds: ''},
    EndpointNetworkConfiguration: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserName":"","Password":"","ClientToken":"","GatewayARN":"","LocationARN":"","Tags":"","AuditDestinationARN":"","CacheAttributes":{"CacheStaleTimeoutInSeconds":""},"EndpointNetworkConfiguration":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "UserName": "",\n  "Password": "",\n  "ClientToken": "",\n  "GatewayARN": "",\n  "LocationARN": "",\n  "Tags": "",\n  "AuditDestinationARN": "",\n  "CacheAttributes": {\n    "CacheStaleTimeoutInSeconds": ""\n  },\n  "EndpointNetworkConfiguration": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"LocationARN\": \"\",\n  \"Tags\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\n  },\n  \"EndpointNetworkConfiguration\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({
  UserName: '',
  Password: '',
  ClientToken: '',
  GatewayARN: '',
  LocationARN: '',
  Tags: '',
  AuditDestinationARN: '',
  CacheAttributes: {CacheStaleTimeoutInSeconds: ''},
  EndpointNetworkConfiguration: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    UserName: '',
    Password: '',
    ClientToken: '',
    GatewayARN: '',
    LocationARN: '',
    Tags: '',
    AuditDestinationARN: '',
    CacheAttributes: {CacheStaleTimeoutInSeconds: ''},
    EndpointNetworkConfiguration: ''
  },
  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}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem');

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

req.type('json');
req.send({
  UserName: '',
  Password: '',
  ClientToken: '',
  GatewayARN: '',
  LocationARN: '',
  Tags: '',
  AuditDestinationARN: '',
  CacheAttributes: {
    CacheStaleTimeoutInSeconds: ''
  },
  EndpointNetworkConfiguration: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    UserName: '',
    Password: '',
    ClientToken: '',
    GatewayARN: '',
    LocationARN: '',
    Tags: '',
    AuditDestinationARN: '',
    CacheAttributes: {CacheStaleTimeoutInSeconds: ''},
    EndpointNetworkConfiguration: ''
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"UserName":"","Password":"","ClientToken":"","GatewayARN":"","LocationARN":"","Tags":"","AuditDestinationARN":"","CacheAttributes":{"CacheStaleTimeoutInSeconds":""},"EndpointNetworkConfiguration":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"UserName": @"",
                              @"Password": @"",
                              @"ClientToken": @"",
                              @"GatewayARN": @"",
                              @"LocationARN": @"",
                              @"Tags": @"",
                              @"AuditDestinationARN": @"",
                              @"CacheAttributes": @{ @"CacheStaleTimeoutInSeconds": @"" },
                              @"EndpointNetworkConfiguration": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"LocationARN\": \"\",\n  \"Tags\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\n  },\n  \"EndpointNetworkConfiguration\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem",
  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([
    'UserName' => '',
    'Password' => '',
    'ClientToken' => '',
    'GatewayARN' => '',
    'LocationARN' => '',
    'Tags' => '',
    'AuditDestinationARN' => '',
    'CacheAttributes' => [
        'CacheStaleTimeoutInSeconds' => ''
    ],
    'EndpointNetworkConfiguration' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem', [
  'body' => '{
  "UserName": "",
  "Password": "",
  "ClientToken": "",
  "GatewayARN": "",
  "LocationARN": "",
  "Tags": "",
  "AuditDestinationARN": "",
  "CacheAttributes": {
    "CacheStaleTimeoutInSeconds": ""
  },
  "EndpointNetworkConfiguration": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'UserName' => '',
  'Password' => '',
  'ClientToken' => '',
  'GatewayARN' => '',
  'LocationARN' => '',
  'Tags' => '',
  'AuditDestinationARN' => '',
  'CacheAttributes' => [
    'CacheStaleTimeoutInSeconds' => ''
  ],
  'EndpointNetworkConfiguration' => ''
]));

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

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

append(json_encode([
  'UserName' => '',
  'Password' => '',
  'ClientToken' => '',
  'GatewayARN' => '',
  'LocationARN' => '',
  'Tags' => '',
  'AuditDestinationARN' => '',
  'CacheAttributes' => [
    'CacheStaleTimeoutInSeconds' => ''
  ],
  'EndpointNetworkConfiguration' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserName": "",
  "Password": "",
  "ClientToken": "",
  "GatewayARN": "",
  "LocationARN": "",
  "Tags": "",
  "AuditDestinationARN": "",
  "CacheAttributes": {
    "CacheStaleTimeoutInSeconds": ""
  },
  "EndpointNetworkConfiguration": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "UserName": "",
  "Password": "",
  "ClientToken": "",
  "GatewayARN": "",
  "LocationARN": "",
  "Tags": "",
  "AuditDestinationARN": "",
  "CacheAttributes": {
    "CacheStaleTimeoutInSeconds": ""
  },
  "EndpointNetworkConfiguration": ""
}'

import http.client

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

payload = "{\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"LocationARN\": \"\",\n  \"Tags\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\n  },\n  \"EndpointNetworkConfiguration\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem"

payload = {
    "UserName": "",
    "Password": "",
    "ClientToken": "",
    "GatewayARN": "",
    "LocationARN": "",
    "Tags": "",
    "AuditDestinationARN": "",
    "CacheAttributes": { "CacheStaleTimeoutInSeconds": "" },
    "EndpointNetworkConfiguration": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem"

payload <- "{\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"LocationARN\": \"\",\n  \"Tags\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\n  },\n  \"EndpointNetworkConfiguration\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"LocationARN\": \"\",\n  \"Tags\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\n  },\n  \"EndpointNetworkConfiguration\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"LocationARN\": \"\",\n  \"Tags\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\n  },\n  \"EndpointNetworkConfiguration\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem";

    let payload = json!({
        "UserName": "",
        "Password": "",
        "ClientToken": "",
        "GatewayARN": "",
        "LocationARN": "",
        "Tags": "",
        "AuditDestinationARN": "",
        "CacheAttributes": json!({"CacheStaleTimeoutInSeconds": ""}),
        "EndpointNetworkConfiguration": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "UserName": "",
  "Password": "",
  "ClientToken": "",
  "GatewayARN": "",
  "LocationARN": "",
  "Tags": "",
  "AuditDestinationARN": "",
  "CacheAttributes": {
    "CacheStaleTimeoutInSeconds": ""
  },
  "EndpointNetworkConfiguration": ""
}'

echo '{
  "UserName": "",
  "Password": "",
  "ClientToken": "",
  "GatewayARN": "",
  "LocationARN": "",
  "Tags": "",
  "AuditDestinationARN": "",
  "CacheAttributes": {
    "CacheStaleTimeoutInSeconds": ""
  },
  "EndpointNetworkConfiguration": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "UserName": "",\n  "Password": "",\n  "ClientToken": "",\n  "GatewayARN": "",\n  "LocationARN": "",\n  "Tags": "",\n  "AuditDestinationARN": "",\n  "CacheAttributes": {\n    "CacheStaleTimeoutInSeconds": ""\n  },\n  "EndpointNetworkConfiguration": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "UserName": "",
  "Password": "",
  "ClientToken": "",
  "GatewayARN": "",
  "LocationARN": "",
  "Tags": "",
  "AuditDestinationARN": "",
  "CacheAttributes": ["CacheStaleTimeoutInSeconds": ""],
  "EndpointNetworkConfiguration": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AssociateFileSystem")! 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 AttachVolume

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "TargetName": "",
  "VolumeARN": "",
  "NetworkInterfaceId": "",
  "DiskId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\",\n  \"TargetName\": \"\",\n  \"VolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"DiskId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume" {:headers {:x-amz-target ""}
                                                                                               :content-type :json
                                                                                               :form-params {:GatewayARN ""
                                                                                                             :TargetName ""
                                                                                                             :VolumeARN ""
                                                                                                             :NetworkInterfaceId ""
                                                                                                             :DiskId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"TargetName\": \"\",\n  \"VolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"DiskId\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"TargetName\": \"\",\n  \"VolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"DiskId\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"TargetName\": \"\",\n  \"VolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"DiskId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"TargetName\": \"\",\n  \"VolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"DiskId\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 105

{
  "GatewayARN": "",
  "TargetName": "",
  "VolumeARN": "",
  "NetworkInterfaceId": "",
  "DiskId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"TargetName\": \"\",\n  \"VolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"DiskId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"TargetName\": \"\",\n  \"VolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"DiskId\": \"\"\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  \"GatewayARN\": \"\",\n  \"TargetName\": \"\",\n  \"VolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"DiskId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"TargetName\": \"\",\n  \"VolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"DiskId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  TargetName: '',
  VolumeARN: '',
  NetworkInterfaceId: '',
  DiskId: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    GatewayARN: '',
    TargetName: '',
    VolumeARN: '',
    NetworkInterfaceId: '',
    DiskId: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","TargetName":"","VolumeARN":"","NetworkInterfaceId":"","DiskId":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "TargetName": "",\n  "VolumeARN": "",\n  "NetworkInterfaceId": "",\n  "DiskId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"TargetName\": \"\",\n  \"VolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"DiskId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({
  GatewayARN: '',
  TargetName: '',
  VolumeARN: '',
  NetworkInterfaceId: '',
  DiskId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    GatewayARN: '',
    TargetName: '',
    VolumeARN: '',
    NetworkInterfaceId: '',
    DiskId: ''
  },
  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}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume');

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

req.type('json');
req.send({
  GatewayARN: '',
  TargetName: '',
  VolumeARN: '',
  NetworkInterfaceId: '',
  DiskId: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    GatewayARN: '',
    TargetName: '',
    VolumeARN: '',
    NetworkInterfaceId: '',
    DiskId: ''
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","TargetName":"","VolumeARN":"","NetworkInterfaceId":"","DiskId":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"TargetName": @"",
                              @"VolumeARN": @"",
                              @"NetworkInterfaceId": @"",
                              @"DiskId": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"TargetName\": \"\",\n  \"VolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"DiskId\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume",
  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([
    'GatewayARN' => '',
    'TargetName' => '',
    'VolumeARN' => '',
    'NetworkInterfaceId' => '',
    'DiskId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume', [
  'body' => '{
  "GatewayARN": "",
  "TargetName": "",
  "VolumeARN": "",
  "NetworkInterfaceId": "",
  "DiskId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => '',
  'TargetName' => '',
  'VolumeARN' => '',
  'NetworkInterfaceId' => '',
  'DiskId' => ''
]));

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

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

append(json_encode([
  'GatewayARN' => '',
  'TargetName' => '',
  'VolumeARN' => '',
  'NetworkInterfaceId' => '',
  'DiskId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "TargetName": "",
  "VolumeARN": "",
  "NetworkInterfaceId": "",
  "DiskId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "TargetName": "",
  "VolumeARN": "",
  "NetworkInterfaceId": "",
  "DiskId": ""
}'

import http.client

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

payload = "{\n  \"GatewayARN\": \"\",\n  \"TargetName\": \"\",\n  \"VolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"DiskId\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume"

payload = {
    "GatewayARN": "",
    "TargetName": "",
    "VolumeARN": "",
    "NetworkInterfaceId": "",
    "DiskId": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"TargetName\": \"\",\n  \"VolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"DiskId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"TargetName\": \"\",\n  \"VolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"DiskId\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"TargetName\": \"\",\n  \"VolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"DiskId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume";

    let payload = json!({
        "GatewayARN": "",
        "TargetName": "",
        "VolumeARN": "",
        "NetworkInterfaceId": "",
        "DiskId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "TargetName": "",
  "VolumeARN": "",
  "NetworkInterfaceId": "",
  "DiskId": ""
}'

echo '{
  "GatewayARN": "",
  "TargetName": "",
  "VolumeARN": "",
  "NetworkInterfaceId": "",
  "DiskId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "TargetName": "",\n  "VolumeARN": "",\n  "NetworkInterfaceId": "",\n  "DiskId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "TargetName": "",
  "VolumeARN": "",
  "NetworkInterfaceId": "",
  "DiskId": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.AttachVolume")! 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 CancelArchival

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "TapeARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival" {:headers {:x-amz-target ""}
                                                                                                 :content-type :json
                                                                                                 :form-params {:GatewayARN ""
                                                                                                               :TapeARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 39

{
  "GatewayARN": "",
  "TapeARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\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  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  TapeARN: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', TapeARN: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","TapeARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "TapeARN": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: '', TapeARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: '', TapeARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival');

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

req.type('json');
req.send({
  GatewayARN: '',
  TapeARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', TapeARN: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","TapeARN":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"TapeARN": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival",
  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([
    'GatewayARN' => '',
    'TapeARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival', [
  'body' => '{
  "GatewayARN": "",
  "TapeARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'GatewayARN' => '',
  'TapeARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "TapeARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "TapeARN": ""
}'

import http.client

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

payload = "{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival"

payload = {
    "GatewayARN": "",
    "TapeARN": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival";

    let payload = json!({
        "GatewayARN": "",
        "TapeARN": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "TapeARN": ""
}'

echo '{
  "GatewayARN": "",
  "TapeARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "TapeARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "TapeARN": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelArchival")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "TapeARN": "arn:aws:storagegateway:us-east-1:999999999999:tape/AMZN01A2A4"
}

POST CancelRetrieval

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "TapeARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:GatewayARN ""
                                                                                                                :TapeARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 39

{
  "GatewayARN": "",
  "TapeARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\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  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  TapeARN: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', TapeARN: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","TapeARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "TapeARN": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: '', TapeARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: '', TapeARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval');

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

req.type('json');
req.send({
  GatewayARN: '',
  TapeARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', TapeARN: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","TapeARN":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"TapeARN": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval",
  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([
    'GatewayARN' => '',
    'TapeARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval', [
  'body' => '{
  "GatewayARN": "",
  "TapeARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'GatewayARN' => '',
  'TapeARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "TapeARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "TapeARN": ""
}'

import http.client

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

payload = "{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval"

payload = {
    "GatewayARN": "",
    "TapeARN": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval";

    let payload = json!({
        "GatewayARN": "",
        "TapeARN": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "TapeARN": ""
}'

echo '{
  "GatewayARN": "",
  "TapeARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "TapeARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "TapeARN": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CancelRetrieval")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "TapeARN": "arn:aws:storagegateway:us-east-1:999999999999:tape/AMZN01A2A4"
}

POST CreateCachediSCSIVolume

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "VolumeSizeInBytes": "",
  "SnapshotId": "",
  "TargetName": "",
  "SourceVolumeARN": "",
  "NetworkInterfaceId": "",
  "ClientToken": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Tags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\",\n  \"VolumeSizeInBytes\": \"\",\n  \"SnapshotId\": \"\",\n  \"TargetName\": \"\",\n  \"SourceVolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"ClientToken\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:GatewayARN ""
                                                                                                                        :VolumeSizeInBytes ""
                                                                                                                        :SnapshotId ""
                                                                                                                        :TargetName ""
                                                                                                                        :SourceVolumeARN ""
                                                                                                                        :NetworkInterfaceId ""
                                                                                                                        :ClientToken ""
                                                                                                                        :KMSEncrypted ""
                                                                                                                        :KMSKey ""
                                                                                                                        :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"VolumeSizeInBytes\": \"\",\n  \"SnapshotId\": \"\",\n  \"TargetName\": \"\",\n  \"SourceVolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"ClientToken\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"VolumeSizeInBytes\": \"\",\n  \"SnapshotId\": \"\",\n  \"TargetName\": \"\",\n  \"SourceVolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"ClientToken\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"VolumeSizeInBytes\": \"\",\n  \"SnapshotId\": \"\",\n  \"TargetName\": \"\",\n  \"SourceVolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"ClientToken\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"VolumeSizeInBytes\": \"\",\n  \"SnapshotId\": \"\",\n  \"TargetName\": \"\",\n  \"SourceVolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"ClientToken\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 215

{
  "GatewayARN": "",
  "VolumeSizeInBytes": "",
  "SnapshotId": "",
  "TargetName": "",
  "SourceVolumeARN": "",
  "NetworkInterfaceId": "",
  "ClientToken": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"VolumeSizeInBytes\": \"\",\n  \"SnapshotId\": \"\",\n  \"TargetName\": \"\",\n  \"SourceVolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"ClientToken\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"VolumeSizeInBytes\": \"\",\n  \"SnapshotId\": \"\",\n  \"TargetName\": \"\",\n  \"SourceVolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"ClientToken\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"VolumeSizeInBytes\": \"\",\n  \"SnapshotId\": \"\",\n  \"TargetName\": \"\",\n  \"SourceVolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"ClientToken\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"VolumeSizeInBytes\": \"\",\n  \"SnapshotId\": \"\",\n  \"TargetName\": \"\",\n  \"SourceVolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"ClientToken\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  VolumeSizeInBytes: '',
  SnapshotId: '',
  TargetName: '',
  SourceVolumeARN: '',
  NetworkInterfaceId: '',
  ClientToken: '',
  KMSEncrypted: '',
  KMSKey: '',
  Tags: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    GatewayARN: '',
    VolumeSizeInBytes: '',
    SnapshotId: '',
    TargetName: '',
    SourceVolumeARN: '',
    NetworkInterfaceId: '',
    ClientToken: '',
    KMSEncrypted: '',
    KMSKey: '',
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","VolumeSizeInBytes":"","SnapshotId":"","TargetName":"","SourceVolumeARN":"","NetworkInterfaceId":"","ClientToken":"","KMSEncrypted":"","KMSKey":"","Tags":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "VolumeSizeInBytes": "",\n  "SnapshotId": "",\n  "TargetName": "",\n  "SourceVolumeARN": "",\n  "NetworkInterfaceId": "",\n  "ClientToken": "",\n  "KMSEncrypted": "",\n  "KMSKey": "",\n  "Tags": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"VolumeSizeInBytes\": \"\",\n  \"SnapshotId\": \"\",\n  \"TargetName\": \"\",\n  \"SourceVolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"ClientToken\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({
  GatewayARN: '',
  VolumeSizeInBytes: '',
  SnapshotId: '',
  TargetName: '',
  SourceVolumeARN: '',
  NetworkInterfaceId: '',
  ClientToken: '',
  KMSEncrypted: '',
  KMSKey: '',
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    GatewayARN: '',
    VolumeSizeInBytes: '',
    SnapshotId: '',
    TargetName: '',
    SourceVolumeARN: '',
    NetworkInterfaceId: '',
    ClientToken: '',
    KMSEncrypted: '',
    KMSKey: '',
    Tags: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume');

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

req.type('json');
req.send({
  GatewayARN: '',
  VolumeSizeInBytes: '',
  SnapshotId: '',
  TargetName: '',
  SourceVolumeARN: '',
  NetworkInterfaceId: '',
  ClientToken: '',
  KMSEncrypted: '',
  KMSKey: '',
  Tags: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    GatewayARN: '',
    VolumeSizeInBytes: '',
    SnapshotId: '',
    TargetName: '',
    SourceVolumeARN: '',
    NetworkInterfaceId: '',
    ClientToken: '',
    KMSEncrypted: '',
    KMSKey: '',
    Tags: ''
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","VolumeSizeInBytes":"","SnapshotId":"","TargetName":"","SourceVolumeARN":"","NetworkInterfaceId":"","ClientToken":"","KMSEncrypted":"","KMSKey":"","Tags":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"VolumeSizeInBytes": @"",
                              @"SnapshotId": @"",
                              @"TargetName": @"",
                              @"SourceVolumeARN": @"",
                              @"NetworkInterfaceId": @"",
                              @"ClientToken": @"",
                              @"KMSEncrypted": @"",
                              @"KMSKey": @"",
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"VolumeSizeInBytes\": \"\",\n  \"SnapshotId\": \"\",\n  \"TargetName\": \"\",\n  \"SourceVolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"ClientToken\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume",
  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([
    'GatewayARN' => '',
    'VolumeSizeInBytes' => '',
    'SnapshotId' => '',
    'TargetName' => '',
    'SourceVolumeARN' => '',
    'NetworkInterfaceId' => '',
    'ClientToken' => '',
    'KMSEncrypted' => '',
    'KMSKey' => '',
    'Tags' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume', [
  'body' => '{
  "GatewayARN": "",
  "VolumeSizeInBytes": "",
  "SnapshotId": "",
  "TargetName": "",
  "SourceVolumeARN": "",
  "NetworkInterfaceId": "",
  "ClientToken": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => '',
  'VolumeSizeInBytes' => '',
  'SnapshotId' => '',
  'TargetName' => '',
  'SourceVolumeARN' => '',
  'NetworkInterfaceId' => '',
  'ClientToken' => '',
  'KMSEncrypted' => '',
  'KMSKey' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'GatewayARN' => '',
  'VolumeSizeInBytes' => '',
  'SnapshotId' => '',
  'TargetName' => '',
  'SourceVolumeARN' => '',
  'NetworkInterfaceId' => '',
  'ClientToken' => '',
  'KMSEncrypted' => '',
  'KMSKey' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "VolumeSizeInBytes": "",
  "SnapshotId": "",
  "TargetName": "",
  "SourceVolumeARN": "",
  "NetworkInterfaceId": "",
  "ClientToken": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "VolumeSizeInBytes": "",
  "SnapshotId": "",
  "TargetName": "",
  "SourceVolumeARN": "",
  "NetworkInterfaceId": "",
  "ClientToken": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"GatewayARN\": \"\",\n  \"VolumeSizeInBytes\": \"\",\n  \"SnapshotId\": \"\",\n  \"TargetName\": \"\",\n  \"SourceVolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"ClientToken\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume"

payload = {
    "GatewayARN": "",
    "VolumeSizeInBytes": "",
    "SnapshotId": "",
    "TargetName": "",
    "SourceVolumeARN": "",
    "NetworkInterfaceId": "",
    "ClientToken": "",
    "KMSEncrypted": "",
    "KMSKey": "",
    "Tags": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"VolumeSizeInBytes\": \"\",\n  \"SnapshotId\": \"\",\n  \"TargetName\": \"\",\n  \"SourceVolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"ClientToken\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"VolumeSizeInBytes\": \"\",\n  \"SnapshotId\": \"\",\n  \"TargetName\": \"\",\n  \"SourceVolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"ClientToken\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"VolumeSizeInBytes\": \"\",\n  \"SnapshotId\": \"\",\n  \"TargetName\": \"\",\n  \"SourceVolumeARN\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"ClientToken\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume";

    let payload = json!({
        "GatewayARN": "",
        "VolumeSizeInBytes": "",
        "SnapshotId": "",
        "TargetName": "",
        "SourceVolumeARN": "",
        "NetworkInterfaceId": "",
        "ClientToken": "",
        "KMSEncrypted": "",
        "KMSKey": "",
        "Tags": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "VolumeSizeInBytes": "",
  "SnapshotId": "",
  "TargetName": "",
  "SourceVolumeARN": "",
  "NetworkInterfaceId": "",
  "ClientToken": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Tags": ""
}'

echo '{
  "GatewayARN": "",
  "VolumeSizeInBytes": "",
  "SnapshotId": "",
  "TargetName": "",
  "SourceVolumeARN": "",
  "NetworkInterfaceId": "",
  "ClientToken": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "VolumeSizeInBytes": "",\n  "SnapshotId": "",\n  "TargetName": "",\n  "SourceVolumeARN": "",\n  "NetworkInterfaceId": "",\n  "ClientToken": "",\n  "KMSEncrypted": "",\n  "KMSKey": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "VolumeSizeInBytes": "",
  "SnapshotId": "",
  "TargetName": "",
  "SourceVolumeARN": "",
  "NetworkInterfaceId": "",
  "ClientToken": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Tags": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateCachediSCSIVolume")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "TargetARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B/target/iqn.1997-05.com.amazon:myvolume",
  "VolumeARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B/volume/vol-1122AABB"
}

POST CreateNFSFileShare

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare

HEADERS

X-Amz-Target

BODY json

{
  "ClientToken": "",
  "NFSFileShareDefaults": "",
  "GatewayARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Role": "",
  "LocationARN": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ClientList": "",
  "Squash": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "Tags": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "VPCEndpointDNSName": "",
  "BucketRegion": "",
  "AuditDestinationARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ClientToken\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"AuditDestinationARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:ClientToken ""
                                                                                                                   :NFSFileShareDefaults ""
                                                                                                                   :GatewayARN ""
                                                                                                                   :KMSEncrypted ""
                                                                                                                   :KMSKey ""
                                                                                                                   :Role ""
                                                                                                                   :LocationARN ""
                                                                                                                   :DefaultStorageClass ""
                                                                                                                   :ObjectACL ""
                                                                                                                   :ClientList ""
                                                                                                                   :Squash ""
                                                                                                                   :ReadOnly ""
                                                                                                                   :GuessMIMETypeEnabled ""
                                                                                                                   :RequesterPays ""
                                                                                                                   :Tags ""
                                                                                                                   :FileShareName ""
                                                                                                                   :CacheAttributes ""
                                                                                                                   :NotificationPolicy ""
                                                                                                                   :VPCEndpointDNSName ""
                                                                                                                   :BucketRegion ""
                                                                                                                   :AuditDestinationARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ClientToken\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"AuditDestinationARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ClientToken\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"AuditDestinationARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ClientToken\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"AuditDestinationARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare"

	payload := strings.NewReader("{\n  \"ClientToken\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"AuditDestinationARN\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 470

{
  "ClientToken": "",
  "NFSFileShareDefaults": "",
  "GatewayARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Role": "",
  "LocationARN": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ClientList": "",
  "Squash": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "Tags": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "VPCEndpointDNSName": "",
  "BucketRegion": "",
  "AuditDestinationARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ClientToken\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"AuditDestinationARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ClientToken\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"AuditDestinationARN\": \"\"\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  \"ClientToken\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"AuditDestinationARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ClientToken\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"AuditDestinationARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ClientToken: '',
  NFSFileShareDefaults: '',
  GatewayARN: '',
  KMSEncrypted: '',
  KMSKey: '',
  Role: '',
  LocationARN: '',
  DefaultStorageClass: '',
  ObjectACL: '',
  ClientList: '',
  Squash: '',
  ReadOnly: '',
  GuessMIMETypeEnabled: '',
  RequesterPays: '',
  Tags: '',
  FileShareName: '',
  CacheAttributes: '',
  NotificationPolicy: '',
  VPCEndpointDNSName: '',
  BucketRegion: '',
  AuditDestinationARN: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ClientToken: '',
    NFSFileShareDefaults: '',
    GatewayARN: '',
    KMSEncrypted: '',
    KMSKey: '',
    Role: '',
    LocationARN: '',
    DefaultStorageClass: '',
    ObjectACL: '',
    ClientList: '',
    Squash: '',
    ReadOnly: '',
    GuessMIMETypeEnabled: '',
    RequesterPays: '',
    Tags: '',
    FileShareName: '',
    CacheAttributes: '',
    NotificationPolicy: '',
    VPCEndpointDNSName: '',
    BucketRegion: '',
    AuditDestinationARN: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ClientToken":"","NFSFileShareDefaults":"","GatewayARN":"","KMSEncrypted":"","KMSKey":"","Role":"","LocationARN":"","DefaultStorageClass":"","ObjectACL":"","ClientList":"","Squash":"","ReadOnly":"","GuessMIMETypeEnabled":"","RequesterPays":"","Tags":"","FileShareName":"","CacheAttributes":"","NotificationPolicy":"","VPCEndpointDNSName":"","BucketRegion":"","AuditDestinationARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ClientToken": "",\n  "NFSFileShareDefaults": "",\n  "GatewayARN": "",\n  "KMSEncrypted": "",\n  "KMSKey": "",\n  "Role": "",\n  "LocationARN": "",\n  "DefaultStorageClass": "",\n  "ObjectACL": "",\n  "ClientList": "",\n  "Squash": "",\n  "ReadOnly": "",\n  "GuessMIMETypeEnabled": "",\n  "RequesterPays": "",\n  "Tags": "",\n  "FileShareName": "",\n  "CacheAttributes": "",\n  "NotificationPolicy": "",\n  "VPCEndpointDNSName": "",\n  "BucketRegion": "",\n  "AuditDestinationARN": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ClientToken\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"AuditDestinationARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({
  ClientToken: '',
  NFSFileShareDefaults: '',
  GatewayARN: '',
  KMSEncrypted: '',
  KMSKey: '',
  Role: '',
  LocationARN: '',
  DefaultStorageClass: '',
  ObjectACL: '',
  ClientList: '',
  Squash: '',
  ReadOnly: '',
  GuessMIMETypeEnabled: '',
  RequesterPays: '',
  Tags: '',
  FileShareName: '',
  CacheAttributes: '',
  NotificationPolicy: '',
  VPCEndpointDNSName: '',
  BucketRegion: '',
  AuditDestinationARN: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ClientToken: '',
    NFSFileShareDefaults: '',
    GatewayARN: '',
    KMSEncrypted: '',
    KMSKey: '',
    Role: '',
    LocationARN: '',
    DefaultStorageClass: '',
    ObjectACL: '',
    ClientList: '',
    Squash: '',
    ReadOnly: '',
    GuessMIMETypeEnabled: '',
    RequesterPays: '',
    Tags: '',
    FileShareName: '',
    CacheAttributes: '',
    NotificationPolicy: '',
    VPCEndpointDNSName: '',
    BucketRegion: '',
    AuditDestinationARN: ''
  },
  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}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare');

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

req.type('json');
req.send({
  ClientToken: '',
  NFSFileShareDefaults: '',
  GatewayARN: '',
  KMSEncrypted: '',
  KMSKey: '',
  Role: '',
  LocationARN: '',
  DefaultStorageClass: '',
  ObjectACL: '',
  ClientList: '',
  Squash: '',
  ReadOnly: '',
  GuessMIMETypeEnabled: '',
  RequesterPays: '',
  Tags: '',
  FileShareName: '',
  CacheAttributes: '',
  NotificationPolicy: '',
  VPCEndpointDNSName: '',
  BucketRegion: '',
  AuditDestinationARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ClientToken: '',
    NFSFileShareDefaults: '',
    GatewayARN: '',
    KMSEncrypted: '',
    KMSKey: '',
    Role: '',
    LocationARN: '',
    DefaultStorageClass: '',
    ObjectACL: '',
    ClientList: '',
    Squash: '',
    ReadOnly: '',
    GuessMIMETypeEnabled: '',
    RequesterPays: '',
    Tags: '',
    FileShareName: '',
    CacheAttributes: '',
    NotificationPolicy: '',
    VPCEndpointDNSName: '',
    BucketRegion: '',
    AuditDestinationARN: ''
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ClientToken":"","NFSFileShareDefaults":"","GatewayARN":"","KMSEncrypted":"","KMSKey":"","Role":"","LocationARN":"","DefaultStorageClass":"","ObjectACL":"","ClientList":"","Squash":"","ReadOnly":"","GuessMIMETypeEnabled":"","RequesterPays":"","Tags":"","FileShareName":"","CacheAttributes":"","NotificationPolicy":"","VPCEndpointDNSName":"","BucketRegion":"","AuditDestinationARN":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ClientToken": @"",
                              @"NFSFileShareDefaults": @"",
                              @"GatewayARN": @"",
                              @"KMSEncrypted": @"",
                              @"KMSKey": @"",
                              @"Role": @"",
                              @"LocationARN": @"",
                              @"DefaultStorageClass": @"",
                              @"ObjectACL": @"",
                              @"ClientList": @"",
                              @"Squash": @"",
                              @"ReadOnly": @"",
                              @"GuessMIMETypeEnabled": @"",
                              @"RequesterPays": @"",
                              @"Tags": @"",
                              @"FileShareName": @"",
                              @"CacheAttributes": @"",
                              @"NotificationPolicy": @"",
                              @"VPCEndpointDNSName": @"",
                              @"BucketRegion": @"",
                              @"AuditDestinationARN": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ClientToken\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"AuditDestinationARN\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare",
  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([
    'ClientToken' => '',
    'NFSFileShareDefaults' => '',
    'GatewayARN' => '',
    'KMSEncrypted' => '',
    'KMSKey' => '',
    'Role' => '',
    'LocationARN' => '',
    'DefaultStorageClass' => '',
    'ObjectACL' => '',
    'ClientList' => '',
    'Squash' => '',
    'ReadOnly' => '',
    'GuessMIMETypeEnabled' => '',
    'RequesterPays' => '',
    'Tags' => '',
    'FileShareName' => '',
    'CacheAttributes' => '',
    'NotificationPolicy' => '',
    'VPCEndpointDNSName' => '',
    'BucketRegion' => '',
    'AuditDestinationARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare', [
  'body' => '{
  "ClientToken": "",
  "NFSFileShareDefaults": "",
  "GatewayARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Role": "",
  "LocationARN": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ClientList": "",
  "Squash": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "Tags": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "VPCEndpointDNSName": "",
  "BucketRegion": "",
  "AuditDestinationARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ClientToken' => '',
  'NFSFileShareDefaults' => '',
  'GatewayARN' => '',
  'KMSEncrypted' => '',
  'KMSKey' => '',
  'Role' => '',
  'LocationARN' => '',
  'DefaultStorageClass' => '',
  'ObjectACL' => '',
  'ClientList' => '',
  'Squash' => '',
  'ReadOnly' => '',
  'GuessMIMETypeEnabled' => '',
  'RequesterPays' => '',
  'Tags' => '',
  'FileShareName' => '',
  'CacheAttributes' => '',
  'NotificationPolicy' => '',
  'VPCEndpointDNSName' => '',
  'BucketRegion' => '',
  'AuditDestinationARN' => ''
]));

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

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

append(json_encode([
  'ClientToken' => '',
  'NFSFileShareDefaults' => '',
  'GatewayARN' => '',
  'KMSEncrypted' => '',
  'KMSKey' => '',
  'Role' => '',
  'LocationARN' => '',
  'DefaultStorageClass' => '',
  'ObjectACL' => '',
  'ClientList' => '',
  'Squash' => '',
  'ReadOnly' => '',
  'GuessMIMETypeEnabled' => '',
  'RequesterPays' => '',
  'Tags' => '',
  'FileShareName' => '',
  'CacheAttributes' => '',
  'NotificationPolicy' => '',
  'VPCEndpointDNSName' => '',
  'BucketRegion' => '',
  'AuditDestinationARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ClientToken": "",
  "NFSFileShareDefaults": "",
  "GatewayARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Role": "",
  "LocationARN": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ClientList": "",
  "Squash": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "Tags": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "VPCEndpointDNSName": "",
  "BucketRegion": "",
  "AuditDestinationARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ClientToken": "",
  "NFSFileShareDefaults": "",
  "GatewayARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Role": "",
  "LocationARN": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ClientList": "",
  "Squash": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "Tags": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "VPCEndpointDNSName": "",
  "BucketRegion": "",
  "AuditDestinationARN": ""
}'

import http.client

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

payload = "{\n  \"ClientToken\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"AuditDestinationARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare"

payload = {
    "ClientToken": "",
    "NFSFileShareDefaults": "",
    "GatewayARN": "",
    "KMSEncrypted": "",
    "KMSKey": "",
    "Role": "",
    "LocationARN": "",
    "DefaultStorageClass": "",
    "ObjectACL": "",
    "ClientList": "",
    "Squash": "",
    "ReadOnly": "",
    "GuessMIMETypeEnabled": "",
    "RequesterPays": "",
    "Tags": "",
    "FileShareName": "",
    "CacheAttributes": "",
    "NotificationPolicy": "",
    "VPCEndpointDNSName": "",
    "BucketRegion": "",
    "AuditDestinationARN": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare"

payload <- "{\n  \"ClientToken\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"AuditDestinationARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"ClientToken\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"AuditDestinationARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"ClientToken\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"AuditDestinationARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare";

    let payload = json!({
        "ClientToken": "",
        "NFSFileShareDefaults": "",
        "GatewayARN": "",
        "KMSEncrypted": "",
        "KMSKey": "",
        "Role": "",
        "LocationARN": "",
        "DefaultStorageClass": "",
        "ObjectACL": "",
        "ClientList": "",
        "Squash": "",
        "ReadOnly": "",
        "GuessMIMETypeEnabled": "",
        "RequesterPays": "",
        "Tags": "",
        "FileShareName": "",
        "CacheAttributes": "",
        "NotificationPolicy": "",
        "VPCEndpointDNSName": "",
        "BucketRegion": "",
        "AuditDestinationARN": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ClientToken": "",
  "NFSFileShareDefaults": "",
  "GatewayARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Role": "",
  "LocationARN": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ClientList": "",
  "Squash": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "Tags": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "VPCEndpointDNSName": "",
  "BucketRegion": "",
  "AuditDestinationARN": ""
}'

echo '{
  "ClientToken": "",
  "NFSFileShareDefaults": "",
  "GatewayARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Role": "",
  "LocationARN": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ClientList": "",
  "Squash": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "Tags": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "VPCEndpointDNSName": "",
  "BucketRegion": "",
  "AuditDestinationARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ClientToken": "",\n  "NFSFileShareDefaults": "",\n  "GatewayARN": "",\n  "KMSEncrypted": "",\n  "KMSKey": "",\n  "Role": "",\n  "LocationARN": "",\n  "DefaultStorageClass": "",\n  "ObjectACL": "",\n  "ClientList": "",\n  "Squash": "",\n  "ReadOnly": "",\n  "GuessMIMETypeEnabled": "",\n  "RequesterPays": "",\n  "Tags": "",\n  "FileShareName": "",\n  "CacheAttributes": "",\n  "NotificationPolicy": "",\n  "VPCEndpointDNSName": "",\n  "BucketRegion": "",\n  "AuditDestinationARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ClientToken": "",
  "NFSFileShareDefaults": "",
  "GatewayARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Role": "",
  "LocationARN": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ClientList": "",
  "Squash": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "Tags": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "VPCEndpointDNSName": "",
  "BucketRegion": "",
  "AuditDestinationARN": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateNFSFileShare")! 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 CreateSMBFileShare

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare

HEADERS

X-Amz-Target

BODY json

{
  "ClientToken": "",
  "GatewayARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Role": "",
  "LocationARN": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "SMBACLEnabled": "",
  "AccessBasedEnumeration": "",
  "AdminUserList": "",
  "ValidUserList": "",
  "InvalidUserList": "",
  "AuditDestinationARN": "",
  "Authentication": "",
  "CaseSensitivity": "",
  "Tags": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "VPCEndpointDNSName": "",
  "BucketRegion": "",
  "OplocksEnabled": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"Authentication\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"OplocksEnabled\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:ClientToken ""
                                                                                                                   :GatewayARN ""
                                                                                                                   :KMSEncrypted ""
                                                                                                                   :KMSKey ""
                                                                                                                   :Role ""
                                                                                                                   :LocationARN ""
                                                                                                                   :DefaultStorageClass ""
                                                                                                                   :ObjectACL ""
                                                                                                                   :ReadOnly ""
                                                                                                                   :GuessMIMETypeEnabled ""
                                                                                                                   :RequesterPays ""
                                                                                                                   :SMBACLEnabled ""
                                                                                                                   :AccessBasedEnumeration ""
                                                                                                                   :AdminUserList ""
                                                                                                                   :ValidUserList ""
                                                                                                                   :InvalidUserList ""
                                                                                                                   :AuditDestinationARN ""
                                                                                                                   :Authentication ""
                                                                                                                   :CaseSensitivity ""
                                                                                                                   :Tags ""
                                                                                                                   :FileShareName ""
                                                                                                                   :CacheAttributes ""
                                                                                                                   :NotificationPolicy ""
                                                                                                                   :VPCEndpointDNSName ""
                                                                                                                   :BucketRegion ""
                                                                                                                   :OplocksEnabled ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"Authentication\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"OplocksEnabled\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"Authentication\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"OplocksEnabled\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"Authentication\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"OplocksEnabled\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare"

	payload := strings.NewReader("{\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"Authentication\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"OplocksEnabled\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 603

{
  "ClientToken": "",
  "GatewayARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Role": "",
  "LocationARN": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "SMBACLEnabled": "",
  "AccessBasedEnumeration": "",
  "AdminUserList": "",
  "ValidUserList": "",
  "InvalidUserList": "",
  "AuditDestinationARN": "",
  "Authentication": "",
  "CaseSensitivity": "",
  "Tags": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "VPCEndpointDNSName": "",
  "BucketRegion": "",
  "OplocksEnabled": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"Authentication\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"OplocksEnabled\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"Authentication\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"OplocksEnabled\": \"\"\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  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"Authentication\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"OplocksEnabled\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"Authentication\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"OplocksEnabled\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ClientToken: '',
  GatewayARN: '',
  KMSEncrypted: '',
  KMSKey: '',
  Role: '',
  LocationARN: '',
  DefaultStorageClass: '',
  ObjectACL: '',
  ReadOnly: '',
  GuessMIMETypeEnabled: '',
  RequesterPays: '',
  SMBACLEnabled: '',
  AccessBasedEnumeration: '',
  AdminUserList: '',
  ValidUserList: '',
  InvalidUserList: '',
  AuditDestinationARN: '',
  Authentication: '',
  CaseSensitivity: '',
  Tags: '',
  FileShareName: '',
  CacheAttributes: '',
  NotificationPolicy: '',
  VPCEndpointDNSName: '',
  BucketRegion: '',
  OplocksEnabled: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ClientToken: '',
    GatewayARN: '',
    KMSEncrypted: '',
    KMSKey: '',
    Role: '',
    LocationARN: '',
    DefaultStorageClass: '',
    ObjectACL: '',
    ReadOnly: '',
    GuessMIMETypeEnabled: '',
    RequesterPays: '',
    SMBACLEnabled: '',
    AccessBasedEnumeration: '',
    AdminUserList: '',
    ValidUserList: '',
    InvalidUserList: '',
    AuditDestinationARN: '',
    Authentication: '',
    CaseSensitivity: '',
    Tags: '',
    FileShareName: '',
    CacheAttributes: '',
    NotificationPolicy: '',
    VPCEndpointDNSName: '',
    BucketRegion: '',
    OplocksEnabled: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ClientToken":"","GatewayARN":"","KMSEncrypted":"","KMSKey":"","Role":"","LocationARN":"","DefaultStorageClass":"","ObjectACL":"","ReadOnly":"","GuessMIMETypeEnabled":"","RequesterPays":"","SMBACLEnabled":"","AccessBasedEnumeration":"","AdminUserList":"","ValidUserList":"","InvalidUserList":"","AuditDestinationARN":"","Authentication":"","CaseSensitivity":"","Tags":"","FileShareName":"","CacheAttributes":"","NotificationPolicy":"","VPCEndpointDNSName":"","BucketRegion":"","OplocksEnabled":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ClientToken": "",\n  "GatewayARN": "",\n  "KMSEncrypted": "",\n  "KMSKey": "",\n  "Role": "",\n  "LocationARN": "",\n  "DefaultStorageClass": "",\n  "ObjectACL": "",\n  "ReadOnly": "",\n  "GuessMIMETypeEnabled": "",\n  "RequesterPays": "",\n  "SMBACLEnabled": "",\n  "AccessBasedEnumeration": "",\n  "AdminUserList": "",\n  "ValidUserList": "",\n  "InvalidUserList": "",\n  "AuditDestinationARN": "",\n  "Authentication": "",\n  "CaseSensitivity": "",\n  "Tags": "",\n  "FileShareName": "",\n  "CacheAttributes": "",\n  "NotificationPolicy": "",\n  "VPCEndpointDNSName": "",\n  "BucketRegion": "",\n  "OplocksEnabled": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"Authentication\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"OplocksEnabled\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({
  ClientToken: '',
  GatewayARN: '',
  KMSEncrypted: '',
  KMSKey: '',
  Role: '',
  LocationARN: '',
  DefaultStorageClass: '',
  ObjectACL: '',
  ReadOnly: '',
  GuessMIMETypeEnabled: '',
  RequesterPays: '',
  SMBACLEnabled: '',
  AccessBasedEnumeration: '',
  AdminUserList: '',
  ValidUserList: '',
  InvalidUserList: '',
  AuditDestinationARN: '',
  Authentication: '',
  CaseSensitivity: '',
  Tags: '',
  FileShareName: '',
  CacheAttributes: '',
  NotificationPolicy: '',
  VPCEndpointDNSName: '',
  BucketRegion: '',
  OplocksEnabled: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ClientToken: '',
    GatewayARN: '',
    KMSEncrypted: '',
    KMSKey: '',
    Role: '',
    LocationARN: '',
    DefaultStorageClass: '',
    ObjectACL: '',
    ReadOnly: '',
    GuessMIMETypeEnabled: '',
    RequesterPays: '',
    SMBACLEnabled: '',
    AccessBasedEnumeration: '',
    AdminUserList: '',
    ValidUserList: '',
    InvalidUserList: '',
    AuditDestinationARN: '',
    Authentication: '',
    CaseSensitivity: '',
    Tags: '',
    FileShareName: '',
    CacheAttributes: '',
    NotificationPolicy: '',
    VPCEndpointDNSName: '',
    BucketRegion: '',
    OplocksEnabled: ''
  },
  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}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare');

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

req.type('json');
req.send({
  ClientToken: '',
  GatewayARN: '',
  KMSEncrypted: '',
  KMSKey: '',
  Role: '',
  LocationARN: '',
  DefaultStorageClass: '',
  ObjectACL: '',
  ReadOnly: '',
  GuessMIMETypeEnabled: '',
  RequesterPays: '',
  SMBACLEnabled: '',
  AccessBasedEnumeration: '',
  AdminUserList: '',
  ValidUserList: '',
  InvalidUserList: '',
  AuditDestinationARN: '',
  Authentication: '',
  CaseSensitivity: '',
  Tags: '',
  FileShareName: '',
  CacheAttributes: '',
  NotificationPolicy: '',
  VPCEndpointDNSName: '',
  BucketRegion: '',
  OplocksEnabled: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ClientToken: '',
    GatewayARN: '',
    KMSEncrypted: '',
    KMSKey: '',
    Role: '',
    LocationARN: '',
    DefaultStorageClass: '',
    ObjectACL: '',
    ReadOnly: '',
    GuessMIMETypeEnabled: '',
    RequesterPays: '',
    SMBACLEnabled: '',
    AccessBasedEnumeration: '',
    AdminUserList: '',
    ValidUserList: '',
    InvalidUserList: '',
    AuditDestinationARN: '',
    Authentication: '',
    CaseSensitivity: '',
    Tags: '',
    FileShareName: '',
    CacheAttributes: '',
    NotificationPolicy: '',
    VPCEndpointDNSName: '',
    BucketRegion: '',
    OplocksEnabled: ''
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ClientToken":"","GatewayARN":"","KMSEncrypted":"","KMSKey":"","Role":"","LocationARN":"","DefaultStorageClass":"","ObjectACL":"","ReadOnly":"","GuessMIMETypeEnabled":"","RequesterPays":"","SMBACLEnabled":"","AccessBasedEnumeration":"","AdminUserList":"","ValidUserList":"","InvalidUserList":"","AuditDestinationARN":"","Authentication":"","CaseSensitivity":"","Tags":"","FileShareName":"","CacheAttributes":"","NotificationPolicy":"","VPCEndpointDNSName":"","BucketRegion":"","OplocksEnabled":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ClientToken": @"",
                              @"GatewayARN": @"",
                              @"KMSEncrypted": @"",
                              @"KMSKey": @"",
                              @"Role": @"",
                              @"LocationARN": @"",
                              @"DefaultStorageClass": @"",
                              @"ObjectACL": @"",
                              @"ReadOnly": @"",
                              @"GuessMIMETypeEnabled": @"",
                              @"RequesterPays": @"",
                              @"SMBACLEnabled": @"",
                              @"AccessBasedEnumeration": @"",
                              @"AdminUserList": @"",
                              @"ValidUserList": @"",
                              @"InvalidUserList": @"",
                              @"AuditDestinationARN": @"",
                              @"Authentication": @"",
                              @"CaseSensitivity": @"",
                              @"Tags": @"",
                              @"FileShareName": @"",
                              @"CacheAttributes": @"",
                              @"NotificationPolicy": @"",
                              @"VPCEndpointDNSName": @"",
                              @"BucketRegion": @"",
                              @"OplocksEnabled": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"Authentication\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"OplocksEnabled\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare",
  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([
    'ClientToken' => '',
    'GatewayARN' => '',
    'KMSEncrypted' => '',
    'KMSKey' => '',
    'Role' => '',
    'LocationARN' => '',
    'DefaultStorageClass' => '',
    'ObjectACL' => '',
    'ReadOnly' => '',
    'GuessMIMETypeEnabled' => '',
    'RequesterPays' => '',
    'SMBACLEnabled' => '',
    'AccessBasedEnumeration' => '',
    'AdminUserList' => '',
    'ValidUserList' => '',
    'InvalidUserList' => '',
    'AuditDestinationARN' => '',
    'Authentication' => '',
    'CaseSensitivity' => '',
    'Tags' => '',
    'FileShareName' => '',
    'CacheAttributes' => '',
    'NotificationPolicy' => '',
    'VPCEndpointDNSName' => '',
    'BucketRegion' => '',
    'OplocksEnabled' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare', [
  'body' => '{
  "ClientToken": "",
  "GatewayARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Role": "",
  "LocationARN": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "SMBACLEnabled": "",
  "AccessBasedEnumeration": "",
  "AdminUserList": "",
  "ValidUserList": "",
  "InvalidUserList": "",
  "AuditDestinationARN": "",
  "Authentication": "",
  "CaseSensitivity": "",
  "Tags": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "VPCEndpointDNSName": "",
  "BucketRegion": "",
  "OplocksEnabled": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ClientToken' => '',
  'GatewayARN' => '',
  'KMSEncrypted' => '',
  'KMSKey' => '',
  'Role' => '',
  'LocationARN' => '',
  'DefaultStorageClass' => '',
  'ObjectACL' => '',
  'ReadOnly' => '',
  'GuessMIMETypeEnabled' => '',
  'RequesterPays' => '',
  'SMBACLEnabled' => '',
  'AccessBasedEnumeration' => '',
  'AdminUserList' => '',
  'ValidUserList' => '',
  'InvalidUserList' => '',
  'AuditDestinationARN' => '',
  'Authentication' => '',
  'CaseSensitivity' => '',
  'Tags' => '',
  'FileShareName' => '',
  'CacheAttributes' => '',
  'NotificationPolicy' => '',
  'VPCEndpointDNSName' => '',
  'BucketRegion' => '',
  'OplocksEnabled' => ''
]));

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

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

append(json_encode([
  'ClientToken' => '',
  'GatewayARN' => '',
  'KMSEncrypted' => '',
  'KMSKey' => '',
  'Role' => '',
  'LocationARN' => '',
  'DefaultStorageClass' => '',
  'ObjectACL' => '',
  'ReadOnly' => '',
  'GuessMIMETypeEnabled' => '',
  'RequesterPays' => '',
  'SMBACLEnabled' => '',
  'AccessBasedEnumeration' => '',
  'AdminUserList' => '',
  'ValidUserList' => '',
  'InvalidUserList' => '',
  'AuditDestinationARN' => '',
  'Authentication' => '',
  'CaseSensitivity' => '',
  'Tags' => '',
  'FileShareName' => '',
  'CacheAttributes' => '',
  'NotificationPolicy' => '',
  'VPCEndpointDNSName' => '',
  'BucketRegion' => '',
  'OplocksEnabled' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ClientToken": "",
  "GatewayARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Role": "",
  "LocationARN": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "SMBACLEnabled": "",
  "AccessBasedEnumeration": "",
  "AdminUserList": "",
  "ValidUserList": "",
  "InvalidUserList": "",
  "AuditDestinationARN": "",
  "Authentication": "",
  "CaseSensitivity": "",
  "Tags": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "VPCEndpointDNSName": "",
  "BucketRegion": "",
  "OplocksEnabled": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ClientToken": "",
  "GatewayARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Role": "",
  "LocationARN": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "SMBACLEnabled": "",
  "AccessBasedEnumeration": "",
  "AdminUserList": "",
  "ValidUserList": "",
  "InvalidUserList": "",
  "AuditDestinationARN": "",
  "Authentication": "",
  "CaseSensitivity": "",
  "Tags": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "VPCEndpointDNSName": "",
  "BucketRegion": "",
  "OplocksEnabled": ""
}'

import http.client

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

payload = "{\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"Authentication\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"OplocksEnabled\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare"

payload = {
    "ClientToken": "",
    "GatewayARN": "",
    "KMSEncrypted": "",
    "KMSKey": "",
    "Role": "",
    "LocationARN": "",
    "DefaultStorageClass": "",
    "ObjectACL": "",
    "ReadOnly": "",
    "GuessMIMETypeEnabled": "",
    "RequesterPays": "",
    "SMBACLEnabled": "",
    "AccessBasedEnumeration": "",
    "AdminUserList": "",
    "ValidUserList": "",
    "InvalidUserList": "",
    "AuditDestinationARN": "",
    "Authentication": "",
    "CaseSensitivity": "",
    "Tags": "",
    "FileShareName": "",
    "CacheAttributes": "",
    "NotificationPolicy": "",
    "VPCEndpointDNSName": "",
    "BucketRegion": "",
    "OplocksEnabled": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare"

payload <- "{\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"Authentication\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"OplocksEnabled\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"Authentication\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"OplocksEnabled\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"ClientToken\": \"\",\n  \"GatewayARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Role\": \"\",\n  \"LocationARN\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"Authentication\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"Tags\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"VPCEndpointDNSName\": \"\",\n  \"BucketRegion\": \"\",\n  \"OplocksEnabled\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare";

    let payload = json!({
        "ClientToken": "",
        "GatewayARN": "",
        "KMSEncrypted": "",
        "KMSKey": "",
        "Role": "",
        "LocationARN": "",
        "DefaultStorageClass": "",
        "ObjectACL": "",
        "ReadOnly": "",
        "GuessMIMETypeEnabled": "",
        "RequesterPays": "",
        "SMBACLEnabled": "",
        "AccessBasedEnumeration": "",
        "AdminUserList": "",
        "ValidUserList": "",
        "InvalidUserList": "",
        "AuditDestinationARN": "",
        "Authentication": "",
        "CaseSensitivity": "",
        "Tags": "",
        "FileShareName": "",
        "CacheAttributes": "",
        "NotificationPolicy": "",
        "VPCEndpointDNSName": "",
        "BucketRegion": "",
        "OplocksEnabled": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ClientToken": "",
  "GatewayARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Role": "",
  "LocationARN": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "SMBACLEnabled": "",
  "AccessBasedEnumeration": "",
  "AdminUserList": "",
  "ValidUserList": "",
  "InvalidUserList": "",
  "AuditDestinationARN": "",
  "Authentication": "",
  "CaseSensitivity": "",
  "Tags": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "VPCEndpointDNSName": "",
  "BucketRegion": "",
  "OplocksEnabled": ""
}'

echo '{
  "ClientToken": "",
  "GatewayARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Role": "",
  "LocationARN": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "SMBACLEnabled": "",
  "AccessBasedEnumeration": "",
  "AdminUserList": "",
  "ValidUserList": "",
  "InvalidUserList": "",
  "AuditDestinationARN": "",
  "Authentication": "",
  "CaseSensitivity": "",
  "Tags": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "VPCEndpointDNSName": "",
  "BucketRegion": "",
  "OplocksEnabled": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ClientToken": "",\n  "GatewayARN": "",\n  "KMSEncrypted": "",\n  "KMSKey": "",\n  "Role": "",\n  "LocationARN": "",\n  "DefaultStorageClass": "",\n  "ObjectACL": "",\n  "ReadOnly": "",\n  "GuessMIMETypeEnabled": "",\n  "RequesterPays": "",\n  "SMBACLEnabled": "",\n  "AccessBasedEnumeration": "",\n  "AdminUserList": "",\n  "ValidUserList": "",\n  "InvalidUserList": "",\n  "AuditDestinationARN": "",\n  "Authentication": "",\n  "CaseSensitivity": "",\n  "Tags": "",\n  "FileShareName": "",\n  "CacheAttributes": "",\n  "NotificationPolicy": "",\n  "VPCEndpointDNSName": "",\n  "BucketRegion": "",\n  "OplocksEnabled": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ClientToken": "",
  "GatewayARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Role": "",
  "LocationARN": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "SMBACLEnabled": "",
  "AccessBasedEnumeration": "",
  "AdminUserList": "",
  "ValidUserList": "",
  "InvalidUserList": "",
  "AuditDestinationARN": "",
  "Authentication": "",
  "CaseSensitivity": "",
  "Tags": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "VPCEndpointDNSName": "",
  "BucketRegion": "",
  "OplocksEnabled": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSMBFileShare")! 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 CreateSnapshot

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot

HEADERS

X-Amz-Target

BODY json

{
  "VolumeARN": "",
  "SnapshotDescription": "",
  "Tags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot" {:headers {:x-amz-target ""}
                                                                                                 :content-type :json
                                                                                                 :form-params {:VolumeARN ""
                                                                                                               :SnapshotDescription ""
                                                                                                               :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot"

	payload := strings.NewReader("{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 64

{
  "VolumeARN": "",
  "SnapshotDescription": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  VolumeARN: '',
  SnapshotDescription: '',
  Tags: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {VolumeARN: '', SnapshotDescription: '', Tags: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"VolumeARN":"","SnapshotDescription":"","Tags":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "VolumeARN": "",\n  "SnapshotDescription": "",\n  "Tags": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({VolumeARN: '', SnapshotDescription: '', Tags: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {VolumeARN: '', SnapshotDescription: '', Tags: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot');

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

req.type('json');
req.send({
  VolumeARN: '',
  SnapshotDescription: '',
  Tags: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {VolumeARN: '', SnapshotDescription: '', Tags: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"VolumeARN":"","SnapshotDescription":"","Tags":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"VolumeARN": @"",
                              @"SnapshotDescription": @"",
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot",
  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([
    'VolumeARN' => '',
    'SnapshotDescription' => '',
    'Tags' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot', [
  'body' => '{
  "VolumeARN": "",
  "SnapshotDescription": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'VolumeARN' => '',
  'SnapshotDescription' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'VolumeARN' => '',
  'SnapshotDescription' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "VolumeARN": "",
  "SnapshotDescription": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "VolumeARN": "",
  "SnapshotDescription": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot"

payload = {
    "VolumeARN": "",
    "SnapshotDescription": "",
    "Tags": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot"

payload <- "{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot";

    let payload = json!({
        "VolumeARN": "",
        "SnapshotDescription": "",
        "Tags": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "VolumeARN": "",
  "SnapshotDescription": "",
  "Tags": ""
}'

echo '{
  "VolumeARN": "",
  "SnapshotDescription": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "VolumeARN": "",\n  "SnapshotDescription": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "VolumeARN": "",
  "SnapshotDescription": "",
  "Tags": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshot")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "SnapshotId": "snap-78e22663",
  "VolumeARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B/volume/vol-1122AABB"
}

POST CreateSnapshotFromVolumeRecoveryPoint

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint

HEADERS

X-Amz-Target

BODY json

{
  "VolumeARN": "",
  "SnapshotDescription": "",
  "Tags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint" {:headers {:x-amz-target ""}
                                                                                                                        :content-type :json
                                                                                                                        :form-params {:VolumeARN ""
                                                                                                                                      :SnapshotDescription ""
                                                                                                                                      :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint"

	payload := strings.NewReader("{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 64

{
  "VolumeARN": "",
  "SnapshotDescription": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  VolumeARN: '',
  SnapshotDescription: '',
  Tags: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {VolumeARN: '', SnapshotDescription: '', Tags: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"VolumeARN":"","SnapshotDescription":"","Tags":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "VolumeARN": "",\n  "SnapshotDescription": "",\n  "Tags": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({VolumeARN: '', SnapshotDescription: '', Tags: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {VolumeARN: '', SnapshotDescription: '', Tags: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint');

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

req.type('json');
req.send({
  VolumeARN: '',
  SnapshotDescription: '',
  Tags: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {VolumeARN: '', SnapshotDescription: '', Tags: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"VolumeARN":"","SnapshotDescription":"","Tags":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"VolumeARN": @"",
                              @"SnapshotDescription": @"",
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint",
  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([
    'VolumeARN' => '',
    'SnapshotDescription' => '',
    'Tags' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint', [
  'body' => '{
  "VolumeARN": "",
  "SnapshotDescription": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'VolumeARN' => '',
  'SnapshotDescription' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'VolumeARN' => '',
  'SnapshotDescription' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "VolumeARN": "",
  "SnapshotDescription": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "VolumeARN": "",
  "SnapshotDescription": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint"

payload = {
    "VolumeARN": "",
    "SnapshotDescription": "",
    "Tags": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint"

payload <- "{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"VolumeARN\": \"\",\n  \"SnapshotDescription\": \"\",\n  \"Tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint";

    let payload = json!({
        "VolumeARN": "",
        "SnapshotDescription": "",
        "Tags": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "VolumeARN": "",
  "SnapshotDescription": "",
  "Tags": ""
}'

echo '{
  "VolumeARN": "",
  "SnapshotDescription": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "VolumeARN": "",\n  "SnapshotDescription": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "VolumeARN": "",
  "SnapshotDescription": "",
  "Tags": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "SnapshotId": "snap-78e22663",
  "VolumeARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B/volume/vol-1122AABB",
  "VolumeRecoveryPointTime": "2017-06-30T10:10:10.000Z"
}

POST CreateStorediSCSIVolume

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "DiskId": "",
  "SnapshotId": "",
  "PreserveExistingData": "",
  "TargetName": "",
  "NetworkInterfaceId": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Tags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\",\n  \"DiskId\": \"\",\n  \"SnapshotId\": \"\",\n  \"PreserveExistingData\": \"\",\n  \"TargetName\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:GatewayARN ""
                                                                                                                        :DiskId ""
                                                                                                                        :SnapshotId ""
                                                                                                                        :PreserveExistingData ""
                                                                                                                        :TargetName ""
                                                                                                                        :NetworkInterfaceId ""
                                                                                                                        :KMSEncrypted ""
                                                                                                                        :KMSKey ""
                                                                                                                        :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"DiskId\": \"\",\n  \"SnapshotId\": \"\",\n  \"PreserveExistingData\": \"\",\n  \"TargetName\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"DiskId\": \"\",\n  \"SnapshotId\": \"\",\n  \"PreserveExistingData\": \"\",\n  \"TargetName\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"DiskId\": \"\",\n  \"SnapshotId\": \"\",\n  \"PreserveExistingData\": \"\",\n  \"TargetName\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"DiskId\": \"\",\n  \"SnapshotId\": \"\",\n  \"PreserveExistingData\": \"\",\n  \"TargetName\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 188

{
  "GatewayARN": "",
  "DiskId": "",
  "SnapshotId": "",
  "PreserveExistingData": "",
  "TargetName": "",
  "NetworkInterfaceId": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"DiskId\": \"\",\n  \"SnapshotId\": \"\",\n  \"PreserveExistingData\": \"\",\n  \"TargetName\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"DiskId\": \"\",\n  \"SnapshotId\": \"\",\n  \"PreserveExistingData\": \"\",\n  \"TargetName\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"DiskId\": \"\",\n  \"SnapshotId\": \"\",\n  \"PreserveExistingData\": \"\",\n  \"TargetName\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"DiskId\": \"\",\n  \"SnapshotId\": \"\",\n  \"PreserveExistingData\": \"\",\n  \"TargetName\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  DiskId: '',
  SnapshotId: '',
  PreserveExistingData: '',
  TargetName: '',
  NetworkInterfaceId: '',
  KMSEncrypted: '',
  KMSKey: '',
  Tags: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    GatewayARN: '',
    DiskId: '',
    SnapshotId: '',
    PreserveExistingData: '',
    TargetName: '',
    NetworkInterfaceId: '',
    KMSEncrypted: '',
    KMSKey: '',
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","DiskId":"","SnapshotId":"","PreserveExistingData":"","TargetName":"","NetworkInterfaceId":"","KMSEncrypted":"","KMSKey":"","Tags":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "DiskId": "",\n  "SnapshotId": "",\n  "PreserveExistingData": "",\n  "TargetName": "",\n  "NetworkInterfaceId": "",\n  "KMSEncrypted": "",\n  "KMSKey": "",\n  "Tags": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"DiskId\": \"\",\n  \"SnapshotId\": \"\",\n  \"PreserveExistingData\": \"\",\n  \"TargetName\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({
  GatewayARN: '',
  DiskId: '',
  SnapshotId: '',
  PreserveExistingData: '',
  TargetName: '',
  NetworkInterfaceId: '',
  KMSEncrypted: '',
  KMSKey: '',
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    GatewayARN: '',
    DiskId: '',
    SnapshotId: '',
    PreserveExistingData: '',
    TargetName: '',
    NetworkInterfaceId: '',
    KMSEncrypted: '',
    KMSKey: '',
    Tags: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume');

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

req.type('json');
req.send({
  GatewayARN: '',
  DiskId: '',
  SnapshotId: '',
  PreserveExistingData: '',
  TargetName: '',
  NetworkInterfaceId: '',
  KMSEncrypted: '',
  KMSKey: '',
  Tags: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    GatewayARN: '',
    DiskId: '',
    SnapshotId: '',
    PreserveExistingData: '',
    TargetName: '',
    NetworkInterfaceId: '',
    KMSEncrypted: '',
    KMSKey: '',
    Tags: ''
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","DiskId":"","SnapshotId":"","PreserveExistingData":"","TargetName":"","NetworkInterfaceId":"","KMSEncrypted":"","KMSKey":"","Tags":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"DiskId": @"",
                              @"SnapshotId": @"",
                              @"PreserveExistingData": @"",
                              @"TargetName": @"",
                              @"NetworkInterfaceId": @"",
                              @"KMSEncrypted": @"",
                              @"KMSKey": @"",
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"DiskId\": \"\",\n  \"SnapshotId\": \"\",\n  \"PreserveExistingData\": \"\",\n  \"TargetName\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume",
  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([
    'GatewayARN' => '',
    'DiskId' => '',
    'SnapshotId' => '',
    'PreserveExistingData' => '',
    'TargetName' => '',
    'NetworkInterfaceId' => '',
    'KMSEncrypted' => '',
    'KMSKey' => '',
    'Tags' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume', [
  'body' => '{
  "GatewayARN": "",
  "DiskId": "",
  "SnapshotId": "",
  "PreserveExistingData": "",
  "TargetName": "",
  "NetworkInterfaceId": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => '',
  'DiskId' => '',
  'SnapshotId' => '',
  'PreserveExistingData' => '',
  'TargetName' => '',
  'NetworkInterfaceId' => '',
  'KMSEncrypted' => '',
  'KMSKey' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'GatewayARN' => '',
  'DiskId' => '',
  'SnapshotId' => '',
  'PreserveExistingData' => '',
  'TargetName' => '',
  'NetworkInterfaceId' => '',
  'KMSEncrypted' => '',
  'KMSKey' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "DiskId": "",
  "SnapshotId": "",
  "PreserveExistingData": "",
  "TargetName": "",
  "NetworkInterfaceId": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "DiskId": "",
  "SnapshotId": "",
  "PreserveExistingData": "",
  "TargetName": "",
  "NetworkInterfaceId": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"GatewayARN\": \"\",\n  \"DiskId\": \"\",\n  \"SnapshotId\": \"\",\n  \"PreserveExistingData\": \"\",\n  \"TargetName\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume"

payload = {
    "GatewayARN": "",
    "DiskId": "",
    "SnapshotId": "",
    "PreserveExistingData": "",
    "TargetName": "",
    "NetworkInterfaceId": "",
    "KMSEncrypted": "",
    "KMSKey": "",
    "Tags": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"DiskId\": \"\",\n  \"SnapshotId\": \"\",\n  \"PreserveExistingData\": \"\",\n  \"TargetName\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"DiskId\": \"\",\n  \"SnapshotId\": \"\",\n  \"PreserveExistingData\": \"\",\n  \"TargetName\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"DiskId\": \"\",\n  \"SnapshotId\": \"\",\n  \"PreserveExistingData\": \"\",\n  \"TargetName\": \"\",\n  \"NetworkInterfaceId\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"Tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume";

    let payload = json!({
        "GatewayARN": "",
        "DiskId": "",
        "SnapshotId": "",
        "PreserveExistingData": "",
        "TargetName": "",
        "NetworkInterfaceId": "",
        "KMSEncrypted": "",
        "KMSKey": "",
        "Tags": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "DiskId": "",
  "SnapshotId": "",
  "PreserveExistingData": "",
  "TargetName": "",
  "NetworkInterfaceId": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Tags": ""
}'

echo '{
  "GatewayARN": "",
  "DiskId": "",
  "SnapshotId": "",
  "PreserveExistingData": "",
  "TargetName": "",
  "NetworkInterfaceId": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "DiskId": "",\n  "SnapshotId": "",\n  "PreserveExistingData": "",\n  "TargetName": "",\n  "NetworkInterfaceId": "",\n  "KMSEncrypted": "",\n  "KMSKey": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "DiskId": "",
  "SnapshotId": "",
  "PreserveExistingData": "",
  "TargetName": "",
  "NetworkInterfaceId": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "Tags": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateStorediSCSIVolume")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "TargetARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B/target/iqn.1997-05.com.amazon:myvolume",
  "VolumeARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B/volume/vol-1122AABB",
  "VolumeSizeInBytes": 1099511627776
}

POST CreateTapePool

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool

HEADERS

X-Amz-Target

BODY json

{
  "PoolName": "",
  "StorageClass": "",
  "RetentionLockType": "",
  "RetentionLockTimeInDays": "",
  "Tags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"PoolName\": \"\",\n  \"StorageClass\": \"\",\n  \"RetentionLockType\": \"\",\n  \"RetentionLockTimeInDays\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool" {:headers {:x-amz-target ""}
                                                                                                 :content-type :json
                                                                                                 :form-params {:PoolName ""
                                                                                                               :StorageClass ""
                                                                                                               :RetentionLockType ""
                                                                                                               :RetentionLockTimeInDays ""
                                                                                                               :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"PoolName\": \"\",\n  \"StorageClass\": \"\",\n  \"RetentionLockType\": \"\",\n  \"RetentionLockTimeInDays\": \"\",\n  \"Tags\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"PoolName\": \"\",\n  \"StorageClass\": \"\",\n  \"RetentionLockType\": \"\",\n  \"RetentionLockTimeInDays\": \"\",\n  \"Tags\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"PoolName\": \"\",\n  \"StorageClass\": \"\",\n  \"RetentionLockType\": \"\",\n  \"RetentionLockTimeInDays\": \"\",\n  \"Tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool"

	payload := strings.NewReader("{\n  \"PoolName\": \"\",\n  \"StorageClass\": \"\",\n  \"RetentionLockType\": \"\",\n  \"RetentionLockTimeInDays\": \"\",\n  \"Tags\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 116

{
  "PoolName": "",
  "StorageClass": "",
  "RetentionLockType": "",
  "RetentionLockTimeInDays": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"PoolName\": \"\",\n  \"StorageClass\": \"\",\n  \"RetentionLockType\": \"\",\n  \"RetentionLockTimeInDays\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"PoolName\": \"\",\n  \"StorageClass\": \"\",\n  \"RetentionLockType\": \"\",\n  \"RetentionLockTimeInDays\": \"\",\n  \"Tags\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"PoolName\": \"\",\n  \"StorageClass\": \"\",\n  \"RetentionLockType\": \"\",\n  \"RetentionLockTimeInDays\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"PoolName\": \"\",\n  \"StorageClass\": \"\",\n  \"RetentionLockType\": \"\",\n  \"RetentionLockTimeInDays\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  PoolName: '',
  StorageClass: '',
  RetentionLockType: '',
  RetentionLockTimeInDays: '',
  Tags: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    PoolName: '',
    StorageClass: '',
    RetentionLockType: '',
    RetentionLockTimeInDays: '',
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"PoolName":"","StorageClass":"","RetentionLockType":"","RetentionLockTimeInDays":"","Tags":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "PoolName": "",\n  "StorageClass": "",\n  "RetentionLockType": "",\n  "RetentionLockTimeInDays": "",\n  "Tags": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"PoolName\": \"\",\n  \"StorageClass\": \"\",\n  \"RetentionLockType\": \"\",\n  \"RetentionLockTimeInDays\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({
  PoolName: '',
  StorageClass: '',
  RetentionLockType: '',
  RetentionLockTimeInDays: '',
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    PoolName: '',
    StorageClass: '',
    RetentionLockType: '',
    RetentionLockTimeInDays: '',
    Tags: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool');

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

req.type('json');
req.send({
  PoolName: '',
  StorageClass: '',
  RetentionLockType: '',
  RetentionLockTimeInDays: '',
  Tags: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    PoolName: '',
    StorageClass: '',
    RetentionLockType: '',
    RetentionLockTimeInDays: '',
    Tags: ''
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"PoolName":"","StorageClass":"","RetentionLockType":"","RetentionLockTimeInDays":"","Tags":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"PoolName": @"",
                              @"StorageClass": @"",
                              @"RetentionLockType": @"",
                              @"RetentionLockTimeInDays": @"",
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"PoolName\": \"\",\n  \"StorageClass\": \"\",\n  \"RetentionLockType\": \"\",\n  \"RetentionLockTimeInDays\": \"\",\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool",
  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([
    'PoolName' => '',
    'StorageClass' => '',
    'RetentionLockType' => '',
    'RetentionLockTimeInDays' => '',
    'Tags' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool', [
  'body' => '{
  "PoolName": "",
  "StorageClass": "",
  "RetentionLockType": "",
  "RetentionLockTimeInDays": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'PoolName' => '',
  'StorageClass' => '',
  'RetentionLockType' => '',
  'RetentionLockTimeInDays' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'PoolName' => '',
  'StorageClass' => '',
  'RetentionLockType' => '',
  'RetentionLockTimeInDays' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PoolName": "",
  "StorageClass": "",
  "RetentionLockType": "",
  "RetentionLockTimeInDays": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PoolName": "",
  "StorageClass": "",
  "RetentionLockType": "",
  "RetentionLockTimeInDays": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"PoolName\": \"\",\n  \"StorageClass\": \"\",\n  \"RetentionLockType\": \"\",\n  \"RetentionLockTimeInDays\": \"\",\n  \"Tags\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool"

payload = {
    "PoolName": "",
    "StorageClass": "",
    "RetentionLockType": "",
    "RetentionLockTimeInDays": "",
    "Tags": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool"

payload <- "{\n  \"PoolName\": \"\",\n  \"StorageClass\": \"\",\n  \"RetentionLockType\": \"\",\n  \"RetentionLockTimeInDays\": \"\",\n  \"Tags\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"PoolName\": \"\",\n  \"StorageClass\": \"\",\n  \"RetentionLockType\": \"\",\n  \"RetentionLockTimeInDays\": \"\",\n  \"Tags\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"PoolName\": \"\",\n  \"StorageClass\": \"\",\n  \"RetentionLockType\": \"\",\n  \"RetentionLockTimeInDays\": \"\",\n  \"Tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool";

    let payload = json!({
        "PoolName": "",
        "StorageClass": "",
        "RetentionLockType": "",
        "RetentionLockTimeInDays": "",
        "Tags": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "PoolName": "",
  "StorageClass": "",
  "RetentionLockType": "",
  "RetentionLockTimeInDays": "",
  "Tags": ""
}'

echo '{
  "PoolName": "",
  "StorageClass": "",
  "RetentionLockType": "",
  "RetentionLockTimeInDays": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "PoolName": "",\n  "StorageClass": "",\n  "RetentionLockType": "",\n  "RetentionLockTimeInDays": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "PoolName": "",
  "StorageClass": "",
  "RetentionLockType": "",
  "RetentionLockTimeInDays": "",
  "Tags": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapePool")! 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 CreateTapeWithBarcode

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "TapeSizeInBytes": "",
  "TapeBarcode": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "PoolId": "",
  "Worm": "",
  "Tags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"TapeBarcode\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:GatewayARN ""
                                                                                                                      :TapeSizeInBytes ""
                                                                                                                      :TapeBarcode ""
                                                                                                                      :KMSEncrypted ""
                                                                                                                      :KMSKey ""
                                                                                                                      :PoolId ""
                                                                                                                      :Worm ""
                                                                                                                      :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"TapeBarcode\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"TapeBarcode\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"TapeBarcode\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"TapeBarcode\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 150

{
  "GatewayARN": "",
  "TapeSizeInBytes": "",
  "TapeBarcode": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "PoolId": "",
  "Worm": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"TapeBarcode\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"TapeBarcode\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"TapeBarcode\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"TapeBarcode\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  TapeSizeInBytes: '',
  TapeBarcode: '',
  KMSEncrypted: '',
  KMSKey: '',
  PoolId: '',
  Worm: '',
  Tags: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    GatewayARN: '',
    TapeSizeInBytes: '',
    TapeBarcode: '',
    KMSEncrypted: '',
    KMSKey: '',
    PoolId: '',
    Worm: '',
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","TapeSizeInBytes":"","TapeBarcode":"","KMSEncrypted":"","KMSKey":"","PoolId":"","Worm":"","Tags":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "TapeSizeInBytes": "",\n  "TapeBarcode": "",\n  "KMSEncrypted": "",\n  "KMSKey": "",\n  "PoolId": "",\n  "Worm": "",\n  "Tags": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"TapeBarcode\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({
  GatewayARN: '',
  TapeSizeInBytes: '',
  TapeBarcode: '',
  KMSEncrypted: '',
  KMSKey: '',
  PoolId: '',
  Worm: '',
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    GatewayARN: '',
    TapeSizeInBytes: '',
    TapeBarcode: '',
    KMSEncrypted: '',
    KMSKey: '',
    PoolId: '',
    Worm: '',
    Tags: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode');

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

req.type('json');
req.send({
  GatewayARN: '',
  TapeSizeInBytes: '',
  TapeBarcode: '',
  KMSEncrypted: '',
  KMSKey: '',
  PoolId: '',
  Worm: '',
  Tags: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    GatewayARN: '',
    TapeSizeInBytes: '',
    TapeBarcode: '',
    KMSEncrypted: '',
    KMSKey: '',
    PoolId: '',
    Worm: '',
    Tags: ''
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","TapeSizeInBytes":"","TapeBarcode":"","KMSEncrypted":"","KMSKey":"","PoolId":"","Worm":"","Tags":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"TapeSizeInBytes": @"",
                              @"TapeBarcode": @"",
                              @"KMSEncrypted": @"",
                              @"KMSKey": @"",
                              @"PoolId": @"",
                              @"Worm": @"",
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"TapeBarcode\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode",
  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([
    'GatewayARN' => '',
    'TapeSizeInBytes' => '',
    'TapeBarcode' => '',
    'KMSEncrypted' => '',
    'KMSKey' => '',
    'PoolId' => '',
    'Worm' => '',
    'Tags' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode', [
  'body' => '{
  "GatewayARN": "",
  "TapeSizeInBytes": "",
  "TapeBarcode": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "PoolId": "",
  "Worm": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => '',
  'TapeSizeInBytes' => '',
  'TapeBarcode' => '',
  'KMSEncrypted' => '',
  'KMSKey' => '',
  'PoolId' => '',
  'Worm' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'GatewayARN' => '',
  'TapeSizeInBytes' => '',
  'TapeBarcode' => '',
  'KMSEncrypted' => '',
  'KMSKey' => '',
  'PoolId' => '',
  'Worm' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "TapeSizeInBytes": "",
  "TapeBarcode": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "PoolId": "",
  "Worm": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "TapeSizeInBytes": "",
  "TapeBarcode": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "PoolId": "",
  "Worm": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"TapeBarcode\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode"

payload = {
    "GatewayARN": "",
    "TapeSizeInBytes": "",
    "TapeBarcode": "",
    "KMSEncrypted": "",
    "KMSKey": "",
    "PoolId": "",
    "Worm": "",
    "Tags": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"TapeBarcode\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"TapeBarcode\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"TapeBarcode\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode";

    let payload = json!({
        "GatewayARN": "",
        "TapeSizeInBytes": "",
        "TapeBarcode": "",
        "KMSEncrypted": "",
        "KMSKey": "",
        "PoolId": "",
        "Worm": "",
        "Tags": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "TapeSizeInBytes": "",
  "TapeBarcode": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "PoolId": "",
  "Worm": "",
  "Tags": ""
}'

echo '{
  "GatewayARN": "",
  "TapeSizeInBytes": "",
  "TapeBarcode": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "PoolId": "",
  "Worm": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "TapeSizeInBytes": "",\n  "TapeBarcode": "",\n  "KMSEncrypted": "",\n  "KMSKey": "",\n  "PoolId": "",\n  "Worm": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "TapeSizeInBytes": "",
  "TapeBarcode": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "PoolId": "",
  "Worm": "",
  "Tags": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapeWithBarcode")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "TapeARN": "arn:aws:storagegateway:us-east-1:999999999999:tape/TEST12345"
}

POST CreateTapes

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "TapeSizeInBytes": "",
  "ClientToken": "",
  "NumTapesToCreate": "",
  "TapeBarcodePrefix": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "PoolId": "",
  "Worm": "",
  "Tags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes");

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"ClientToken\": \"\",\n  \"NumTapesToCreate\": \"\",\n  \"TapeBarcodePrefix\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes" {:headers {:x-amz-target ""}
                                                                                              :content-type :json
                                                                                              :form-params {:GatewayARN ""
                                                                                                            :TapeSizeInBytes ""
                                                                                                            :ClientToken ""
                                                                                                            :NumTapesToCreate ""
                                                                                                            :TapeBarcodePrefix ""
                                                                                                            :KMSEncrypted ""
                                                                                                            :KMSKey ""
                                                                                                            :PoolId ""
                                                                                                            :Worm ""
                                                                                                            :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"ClientToken\": \"\",\n  \"NumTapesToCreate\": \"\",\n  \"TapeBarcodePrefix\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"ClientToken\": \"\",\n  \"NumTapesToCreate\": \"\",\n  \"TapeBarcodePrefix\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"ClientToken\": \"\",\n  \"NumTapesToCreate\": \"\",\n  \"TapeBarcodePrefix\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"ClientToken\": \"\",\n  \"NumTapesToCreate\": \"\",\n  \"TapeBarcodePrefix\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 203

{
  "GatewayARN": "",
  "TapeSizeInBytes": "",
  "ClientToken": "",
  "NumTapesToCreate": "",
  "TapeBarcodePrefix": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "PoolId": "",
  "Worm": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"ClientToken\": \"\",\n  \"NumTapesToCreate\": \"\",\n  \"TapeBarcodePrefix\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"ClientToken\": \"\",\n  \"NumTapesToCreate\": \"\",\n  \"TapeBarcodePrefix\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"ClientToken\": \"\",\n  \"NumTapesToCreate\": \"\",\n  \"TapeBarcodePrefix\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"ClientToken\": \"\",\n  \"NumTapesToCreate\": \"\",\n  \"TapeBarcodePrefix\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  TapeSizeInBytes: '',
  ClientToken: '',
  NumTapesToCreate: '',
  TapeBarcodePrefix: '',
  KMSEncrypted: '',
  KMSKey: '',
  PoolId: '',
  Worm: '',
  Tags: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    GatewayARN: '',
    TapeSizeInBytes: '',
    ClientToken: '',
    NumTapesToCreate: '',
    TapeBarcodePrefix: '',
    KMSEncrypted: '',
    KMSKey: '',
    PoolId: '',
    Worm: '',
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","TapeSizeInBytes":"","ClientToken":"","NumTapesToCreate":"","TapeBarcodePrefix":"","KMSEncrypted":"","KMSKey":"","PoolId":"","Worm":"","Tags":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "TapeSizeInBytes": "",\n  "ClientToken": "",\n  "NumTapesToCreate": "",\n  "TapeBarcodePrefix": "",\n  "KMSEncrypted": "",\n  "KMSKey": "",\n  "PoolId": "",\n  "Worm": "",\n  "Tags": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"ClientToken\": \"\",\n  \"NumTapesToCreate\": \"\",\n  \"TapeBarcodePrefix\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({
  GatewayARN: '',
  TapeSizeInBytes: '',
  ClientToken: '',
  NumTapesToCreate: '',
  TapeBarcodePrefix: '',
  KMSEncrypted: '',
  KMSKey: '',
  PoolId: '',
  Worm: '',
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    GatewayARN: '',
    TapeSizeInBytes: '',
    ClientToken: '',
    NumTapesToCreate: '',
    TapeBarcodePrefix: '',
    KMSEncrypted: '',
    KMSKey: '',
    PoolId: '',
    Worm: '',
    Tags: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes');

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

req.type('json');
req.send({
  GatewayARN: '',
  TapeSizeInBytes: '',
  ClientToken: '',
  NumTapesToCreate: '',
  TapeBarcodePrefix: '',
  KMSEncrypted: '',
  KMSKey: '',
  PoolId: '',
  Worm: '',
  Tags: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    GatewayARN: '',
    TapeSizeInBytes: '',
    ClientToken: '',
    NumTapesToCreate: '',
    TapeBarcodePrefix: '',
    KMSEncrypted: '',
    KMSKey: '',
    PoolId: '',
    Worm: '',
    Tags: ''
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","TapeSizeInBytes":"","ClientToken":"","NumTapesToCreate":"","TapeBarcodePrefix":"","KMSEncrypted":"","KMSKey":"","PoolId":"","Worm":"","Tags":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"TapeSizeInBytes": @"",
                              @"ClientToken": @"",
                              @"NumTapesToCreate": @"",
                              @"TapeBarcodePrefix": @"",
                              @"KMSEncrypted": @"",
                              @"KMSKey": @"",
                              @"PoolId": @"",
                              @"Worm": @"",
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"ClientToken\": \"\",\n  \"NumTapesToCreate\": \"\",\n  \"TapeBarcodePrefix\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes",
  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([
    'GatewayARN' => '',
    'TapeSizeInBytes' => '',
    'ClientToken' => '',
    'NumTapesToCreate' => '',
    'TapeBarcodePrefix' => '',
    'KMSEncrypted' => '',
    'KMSKey' => '',
    'PoolId' => '',
    'Worm' => '',
    'Tags' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes', [
  'body' => '{
  "GatewayARN": "",
  "TapeSizeInBytes": "",
  "ClientToken": "",
  "NumTapesToCreate": "",
  "TapeBarcodePrefix": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "PoolId": "",
  "Worm": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => '',
  'TapeSizeInBytes' => '',
  'ClientToken' => '',
  'NumTapesToCreate' => '',
  'TapeBarcodePrefix' => '',
  'KMSEncrypted' => '',
  'KMSKey' => '',
  'PoolId' => '',
  'Worm' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'GatewayARN' => '',
  'TapeSizeInBytes' => '',
  'ClientToken' => '',
  'NumTapesToCreate' => '',
  'TapeBarcodePrefix' => '',
  'KMSEncrypted' => '',
  'KMSKey' => '',
  'PoolId' => '',
  'Worm' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "TapeSizeInBytes": "",
  "ClientToken": "",
  "NumTapesToCreate": "",
  "TapeBarcodePrefix": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "PoolId": "",
  "Worm": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "TapeSizeInBytes": "",
  "ClientToken": "",
  "NumTapesToCreate": "",
  "TapeBarcodePrefix": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "PoolId": "",
  "Worm": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"ClientToken\": \"\",\n  \"NumTapesToCreate\": \"\",\n  \"TapeBarcodePrefix\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes"

payload = {
    "GatewayARN": "",
    "TapeSizeInBytes": "",
    "ClientToken": "",
    "NumTapesToCreate": "",
    "TapeBarcodePrefix": "",
    "KMSEncrypted": "",
    "KMSKey": "",
    "PoolId": "",
    "Worm": "",
    "Tags": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"ClientToken\": \"\",\n  \"NumTapesToCreate\": \"\",\n  \"TapeBarcodePrefix\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"ClientToken\": \"\",\n  \"NumTapesToCreate\": \"\",\n  \"TapeBarcodePrefix\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"TapeSizeInBytes\": \"\",\n  \"ClientToken\": \"\",\n  \"NumTapesToCreate\": \"\",\n  \"TapeBarcodePrefix\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"PoolId\": \"\",\n  \"Worm\": \"\",\n  \"Tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes";

    let payload = json!({
        "GatewayARN": "",
        "TapeSizeInBytes": "",
        "ClientToken": "",
        "NumTapesToCreate": "",
        "TapeBarcodePrefix": "",
        "KMSEncrypted": "",
        "KMSKey": "",
        "PoolId": "",
        "Worm": "",
        "Tags": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "TapeSizeInBytes": "",
  "ClientToken": "",
  "NumTapesToCreate": "",
  "TapeBarcodePrefix": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "PoolId": "",
  "Worm": "",
  "Tags": ""
}'

echo '{
  "GatewayARN": "",
  "TapeSizeInBytes": "",
  "ClientToken": "",
  "NumTapesToCreate": "",
  "TapeBarcodePrefix": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "PoolId": "",
  "Worm": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "TapeSizeInBytes": "",\n  "ClientToken": "",\n  "NumTapesToCreate": "",\n  "TapeBarcodePrefix": "",\n  "KMSEncrypted": "",\n  "KMSKey": "",\n  "PoolId": "",\n  "Worm": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "TapeSizeInBytes": "",
  "ClientToken": "",
  "NumTapesToCreate": "",
  "TapeBarcodePrefix": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "PoolId": "",
  "Worm": "",
  "Tags": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.CreateTapes")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "TapeARNs": [
    "arn:aws:storagegateway:us-east-1:999999999999:tape/TEST38A29D",
    "arn:aws:storagegateway:us-east-1:204469490176:tape/TEST3AA29F",
    "arn:aws:storagegateway:us-east-1:204469490176:tape/TEST3BA29E"
  ]
}

POST DeleteAutomaticTapeCreationPolicy

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy" {:headers {:x-amz-target ""}
                                                                                                                    :content-type :json
                                                                                                                    :form-params {:GatewayARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "GatewayARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\"\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  \"GatewayARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy');

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

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

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}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy",
  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([
    'GatewayARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy', [
  'body' => '{
  "GatewayARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'GatewayARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

import http.client

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

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

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy"

payload = { "GatewayARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy"

payload <- "{\n  \"GatewayARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy")

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy";

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": ""
}'

echo '{
  "GatewayARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["GatewayARN": ""] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy")! 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 DeleteBandwidthRateLimit

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "BandwidthType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:GatewayARN ""
                                                                                                                         :BandwidthType ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"BandwidthType\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"BandwidthType\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"BandwidthType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"BandwidthType\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 45

{
  "GatewayARN": "",
  "BandwidthType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"BandwidthType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"BandwidthType\": \"\"\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  \"GatewayARN\": \"\",\n  \"BandwidthType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"BandwidthType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  BandwidthType: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', BandwidthType: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","BandwidthType":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "BandwidthType": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"BandwidthType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: '', BandwidthType: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: '', BandwidthType: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit');

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

req.type('json');
req.send({
  GatewayARN: '',
  BandwidthType: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', BandwidthType: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","BandwidthType":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"BandwidthType": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"BandwidthType\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit",
  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([
    'GatewayARN' => '',
    'BandwidthType' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit', [
  'body' => '{
  "GatewayARN": "",
  "BandwidthType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'GatewayARN' => '',
  'BandwidthType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "BandwidthType": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "BandwidthType": ""
}'

import http.client

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

payload = "{\n  \"GatewayARN\": \"\",\n  \"BandwidthType\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit"

payload = {
    "GatewayARN": "",
    "BandwidthType": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"BandwidthType\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"BandwidthType\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"BandwidthType\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit";

    let payload = json!({
        "GatewayARN": "",
        "BandwidthType": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "BandwidthType": ""
}'

echo '{
  "GatewayARN": "",
  "BandwidthType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "BandwidthType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "BandwidthType": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteBandwidthRateLimit")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "GatewayARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B"
}

POST DeleteChapCredentials

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials

HEADERS

X-Amz-Target

BODY json

{
  "TargetARN": "",
  "InitiatorName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:TargetARN ""
                                                                                                                      :InitiatorName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TargetARN\": \"\",\n  \"InitiatorName\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TargetARN\": \"\",\n  \"InitiatorName\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TargetARN\": \"\",\n  \"InitiatorName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials"

	payload := strings.NewReader("{\n  \"TargetARN\": \"\",\n  \"InitiatorName\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 44

{
  "TargetARN": "",
  "InitiatorName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TargetARN\": \"\",\n  \"InitiatorName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TargetARN\": \"\",\n  \"InitiatorName\": \"\"\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  \"TargetARN\": \"\",\n  \"InitiatorName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TargetARN\": \"\",\n  \"InitiatorName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TargetARN: '',
  InitiatorName: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TargetARN: '', InitiatorName: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TargetARN":"","InitiatorName":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TargetARN": "",\n  "InitiatorName": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TargetARN\": \"\",\n  \"InitiatorName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({TargetARN: '', InitiatorName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {TargetARN: '', InitiatorName: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials');

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

req.type('json');
req.send({
  TargetARN: '',
  InitiatorName: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TargetARN: '', InitiatorName: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TargetARN":"","InitiatorName":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"TargetARN": @"",
                              @"InitiatorName": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TargetARN\": \"\",\n  \"InitiatorName\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials",
  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([
    'TargetARN' => '',
    'InitiatorName' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials', [
  'body' => '{
  "TargetARN": "",
  "InitiatorName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'TargetARN' => '',
  'InitiatorName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TargetARN": "",
  "InitiatorName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TargetARN": "",
  "InitiatorName": ""
}'

import http.client

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

payload = "{\n  \"TargetARN\": \"\",\n  \"InitiatorName\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials"

payload = {
    "TargetARN": "",
    "InitiatorName": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials"

payload <- "{\n  \"TargetARN\": \"\",\n  \"InitiatorName\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"TargetARN\": \"\",\n  \"InitiatorName\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"TargetARN\": \"\",\n  \"InitiatorName\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials";

    let payload = json!({
        "TargetARN": "",
        "InitiatorName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "TargetARN": "",
  "InitiatorName": ""
}'

echo '{
  "TargetARN": "",
  "InitiatorName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TargetARN": "",\n  "InitiatorName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TargetARN": "",
  "InitiatorName": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteChapCredentials")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "InitiatorName": "iqn.1991-05.com.microsoft:computername.domain.example.com",
  "TargetARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B/target/iqn.1997-05.com.amazon:myvolume"
}

POST DeleteFileShare

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare

HEADERS

X-Amz-Target

BODY json

{
  "FileShareARN": "",
  "ForceDelete": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:FileShareARN ""
                                                                                                                :ForceDelete ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"FileShareARN\": \"\",\n  \"ForceDelete\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"FileShareARN\": \"\",\n  \"ForceDelete\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"FileShareARN\": \"\",\n  \"ForceDelete\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare"

	payload := strings.NewReader("{\n  \"FileShareARN\": \"\",\n  \"ForceDelete\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 45

{
  "FileShareARN": "",
  "ForceDelete": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"FileShareARN\": \"\",\n  \"ForceDelete\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"FileShareARN\": \"\",\n  \"ForceDelete\": \"\"\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  \"FileShareARN\": \"\",\n  \"ForceDelete\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"FileShareARN\": \"\",\n  \"ForceDelete\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  FileShareARN: '',
  ForceDelete: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {FileShareARN: '', ForceDelete: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FileShareARN":"","ForceDelete":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "FileShareARN": "",\n  "ForceDelete": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"FileShareARN\": \"\",\n  \"ForceDelete\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({FileShareARN: '', ForceDelete: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {FileShareARN: '', ForceDelete: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare');

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

req.type('json');
req.send({
  FileShareARN: '',
  ForceDelete: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {FileShareARN: '', ForceDelete: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FileShareARN":"","ForceDelete":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"FileShareARN": @"",
                              @"ForceDelete": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"FileShareARN\": \"\",\n  \"ForceDelete\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare",
  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([
    'FileShareARN' => '',
    'ForceDelete' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare', [
  'body' => '{
  "FileShareARN": "",
  "ForceDelete": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'FileShareARN' => '',
  'ForceDelete' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FileShareARN": "",
  "ForceDelete": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FileShareARN": "",
  "ForceDelete": ""
}'

import http.client

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

payload = "{\n  \"FileShareARN\": \"\",\n  \"ForceDelete\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare"

payload = {
    "FileShareARN": "",
    "ForceDelete": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare"

payload <- "{\n  \"FileShareARN\": \"\",\n  \"ForceDelete\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"FileShareARN\": \"\",\n  \"ForceDelete\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"FileShareARN\": \"\",\n  \"ForceDelete\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare";

    let payload = json!({
        "FileShareARN": "",
        "ForceDelete": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "FileShareARN": "",
  "ForceDelete": ""
}'

echo '{
  "FileShareARN": "",
  "ForceDelete": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "FileShareARN": "",\n  "ForceDelete": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "FileShareARN": "",
  "ForceDelete": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteFileShare")! 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 DeleteGateway

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway" {:headers {:x-amz-target ""}
                                                                                                :content-type :json
                                                                                                :form-params {:GatewayARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\"\n}")

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

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "GatewayARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\"\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  \"GatewayARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway');

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

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

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}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway",
  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([
    'GatewayARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway', [
  'body' => '{
  "GatewayARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'GatewayARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

import http.client

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

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

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway"

payload = { "GatewayARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway"

payload <- "{\n  \"GatewayARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway")

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway";

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

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": ""
}'

echo '{
  "GatewayARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["GatewayARN": ""] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteGateway")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "GatewayARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B"
}

POST DeleteSnapshotSchedule

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule

HEADERS

X-Amz-Target

BODY json

{
  "VolumeARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"VolumeARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:VolumeARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"VolumeARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"VolumeARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"VolumeARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule"

	payload := strings.NewReader("{\n  \"VolumeARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 21

{
  "VolumeARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"VolumeARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"VolumeARN\": \"\"\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  \"VolumeARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"VolumeARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  VolumeARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {VolumeARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"VolumeARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "VolumeARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"VolumeARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({VolumeARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {VolumeARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  VolumeARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {VolumeARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"VolumeARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"VolumeARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"VolumeARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule",
  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([
    'VolumeARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule', [
  'body' => '{
  "VolumeARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'VolumeARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'VolumeARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "VolumeARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "VolumeARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"VolumeARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule"

payload = { "VolumeARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule"

payload <- "{\n  \"VolumeARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"VolumeARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"VolumeARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule";

    let payload = json!({"VolumeARN": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "VolumeARN": ""
}'

echo '{
  "VolumeARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "VolumeARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["VolumeARN": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteSnapshotSchedule")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "VolumeARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B/volume/vol-1122AABB"
}

POST DeleteTape

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "TapeARN": "",
  "BypassGovernanceRetention": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape" {:headers {:x-amz-target ""}
                                                                                             :content-type :json
                                                                                             :form-params {:GatewayARN ""
                                                                                                           :TapeARN ""
                                                                                                           :BypassGovernanceRetention ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 74

{
  "GatewayARN": "",
  "TapeARN": "",
  "BypassGovernanceRetention": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\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  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  TapeARN: '',
  BypassGovernanceRetention: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', TapeARN: '', BypassGovernanceRetention: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","TapeARN":"","BypassGovernanceRetention":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "TapeARN": "",\n  "BypassGovernanceRetention": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: '', TapeARN: '', BypassGovernanceRetention: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: '', TapeARN: '', BypassGovernanceRetention: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: '',
  TapeARN: '',
  BypassGovernanceRetention: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', TapeARN: '', BypassGovernanceRetention: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","TapeARN":"","BypassGovernanceRetention":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"TapeARN": @"",
                              @"BypassGovernanceRetention": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape",
  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([
    'GatewayARN' => '',
    'TapeARN' => '',
    'BypassGovernanceRetention' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape', [
  'body' => '{
  "GatewayARN": "",
  "TapeARN": "",
  "BypassGovernanceRetention": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => '',
  'TapeARN' => '',
  'BypassGovernanceRetention' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => '',
  'TapeARN' => '',
  'BypassGovernanceRetention' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "TapeARN": "",
  "BypassGovernanceRetention": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "TapeARN": "",
  "BypassGovernanceRetention": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape"

payload = {
    "GatewayARN": "",
    "TapeARN": "",
    "BypassGovernanceRetention": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape";

    let payload = json!({
        "GatewayARN": "",
        "TapeARN": "",
        "BypassGovernanceRetention": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "TapeARN": "",
  "BypassGovernanceRetention": ""
}'

echo '{
  "GatewayARN": "",
  "TapeARN": "",
  "BypassGovernanceRetention": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "TapeARN": "",\n  "BypassGovernanceRetention": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "TapeARN": "",
  "BypassGovernanceRetention": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTape")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "TapeARN": "arn:aws:storagegateway:us-east-1:204469490176:tape/TEST05A2A0"
}

POST DeleteTapeArchive

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive

HEADERS

X-Amz-Target

BODY json

{
  "TapeARN": "",
  "BypassGovernanceRetention": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:TapeARN ""
                                                                                                                  :BypassGovernanceRetention ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive"

	payload := strings.NewReader("{\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 54

{
  "TapeARN": "",
  "BypassGovernanceRetention": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\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  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TapeARN: '',
  BypassGovernanceRetention: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TapeARN: '', BypassGovernanceRetention: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TapeARN":"","BypassGovernanceRetention":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TapeARN": "",\n  "BypassGovernanceRetention": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({TapeARN: '', BypassGovernanceRetention: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {TapeARN: '', BypassGovernanceRetention: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TapeARN: '',
  BypassGovernanceRetention: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TapeARN: '', BypassGovernanceRetention: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TapeARN":"","BypassGovernanceRetention":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"TapeARN": @"",
                              @"BypassGovernanceRetention": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive",
  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([
    'TapeARN' => '',
    'BypassGovernanceRetention' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive', [
  'body' => '{
  "TapeARN": "",
  "BypassGovernanceRetention": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TapeARN' => '',
  'BypassGovernanceRetention' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TapeARN' => '',
  'BypassGovernanceRetention' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TapeARN": "",
  "BypassGovernanceRetention": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TapeARN": "",
  "BypassGovernanceRetention": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive"

payload = {
    "TapeARN": "",
    "BypassGovernanceRetention": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive"

payload <- "{\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"TapeARN\": \"\",\n  \"BypassGovernanceRetention\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive";

    let payload = json!({
        "TapeARN": "",
        "BypassGovernanceRetention": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "TapeARN": "",
  "BypassGovernanceRetention": ""
}'

echo '{
  "TapeARN": "",
  "BypassGovernanceRetention": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TapeARN": "",\n  "BypassGovernanceRetention": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TapeARN": "",
  "BypassGovernanceRetention": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapeArchive")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "TapeARN": "arn:aws:storagegateway:us-east-1:204469490176:tape/TEST05A2A0"
}

POST DeleteTapePool

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool

HEADERS

X-Amz-Target

BODY json

{
  "PoolARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"PoolARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool" {:headers {:x-amz-target ""}
                                                                                                 :content-type :json
                                                                                                 :form-params {:PoolARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"PoolARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"PoolARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"PoolARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool"

	payload := strings.NewReader("{\n  \"PoolARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 19

{
  "PoolARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"PoolARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"PoolARN\": \"\"\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  \"PoolARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"PoolARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  PoolARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {PoolARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"PoolARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "PoolARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"PoolARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({PoolARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {PoolARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  PoolARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {PoolARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"PoolARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"PoolARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"PoolARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool",
  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([
    'PoolARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool', [
  'body' => '{
  "PoolARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'PoolARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'PoolARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PoolARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PoolARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"PoolARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool"

payload = { "PoolARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool"

payload <- "{\n  \"PoolARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"PoolARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"PoolARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool";

    let payload = json!({"PoolARN": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "PoolARN": ""
}'

echo '{
  "PoolARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "PoolARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["PoolARN": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteTapePool")! 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 DeleteVolume

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume

HEADERS

X-Amz-Target

BODY json

{
  "VolumeARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"VolumeARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume" {:headers {:x-amz-target ""}
                                                                                               :content-type :json
                                                                                               :form-params {:VolumeARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"VolumeARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"VolumeARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"VolumeARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume"

	payload := strings.NewReader("{\n  \"VolumeARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 21

{
  "VolumeARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"VolumeARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"VolumeARN\": \"\"\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  \"VolumeARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"VolumeARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  VolumeARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {VolumeARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"VolumeARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "VolumeARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"VolumeARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({VolumeARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {VolumeARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  VolumeARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {VolumeARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"VolumeARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"VolumeARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"VolumeARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume",
  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([
    'VolumeARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume', [
  'body' => '{
  "VolumeARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'VolumeARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'VolumeARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "VolumeARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "VolumeARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"VolumeARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume"

payload = { "VolumeARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume"

payload <- "{\n  \"VolumeARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"VolumeARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"VolumeARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume";

    let payload = json!({"VolumeARN": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "VolumeARN": ""
}'

echo '{
  "VolumeARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "VolumeARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["VolumeARN": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DeleteVolume")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "VolumeARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B/volume/vol-1122AABB"
}

POST DescribeAvailabilityMonitorTest

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest" {:headers {:x-amz-target ""}
                                                                                                                  :content-type :json
                                                                                                                  :form-params {:GatewayARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "GatewayARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\"\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  \"GatewayARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest",
  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([
    'GatewayARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest', [
  'body' => '{
  "GatewayARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest"

payload = { "GatewayARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest"

payload <- "{\n  \"GatewayARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest";

    let payload = json!({"GatewayARN": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": ""
}'

echo '{
  "GatewayARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["GatewayARN": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeAvailabilityMonitorTest")! 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 DescribeBandwidthRateLimit

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:GatewayARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "GatewayARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\"\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  \"GatewayARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit",
  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([
    'GatewayARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit', [
  'body' => '{
  "GatewayARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit"

payload = { "GatewayARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit"

payload <- "{\n  \"GatewayARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit";

    let payload = json!({"GatewayARN": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": ""
}'

echo '{
  "GatewayARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["GatewayARN": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimit")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "AverageDownloadRateLimitInBitsPerSec": 204800,
  "AverageUploadRateLimitInBitsPerSec": 102400,
  "GatewayARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B"
}

POST DescribeBandwidthRateLimitSchedule

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule" {:headers {:x-amz-target ""}
                                                                                                                     :content-type :json
                                                                                                                     :form-params {:GatewayARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "GatewayARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\"\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  \"GatewayARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule",
  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([
    'GatewayARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule', [
  'body' => '{
  "GatewayARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule"

payload = { "GatewayARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule"

payload <- "{\n  \"GatewayARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule";

    let payload = json!({"GatewayARN": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": ""
}'

echo '{
  "GatewayARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["GatewayARN": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeBandwidthRateLimitSchedule")! 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 DescribeCache

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache" {:headers {:x-amz-target ""}
                                                                                                :content-type :json
                                                                                                :form-params {:GatewayARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "GatewayARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\"\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  \"GatewayARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache",
  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([
    'GatewayARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache', [
  'body' => '{
  "GatewayARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache"

payload = { "GatewayARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache"

payload <- "{\n  \"GatewayARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache";

    let payload = json!({"GatewayARN": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": ""
}'

echo '{
  "GatewayARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["GatewayARN": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCache")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "CacheAllocatedInBytes": 2199023255552,
  "CacheDirtyPercentage": 0.07,
  "CacheHitPercentage": 99.68,
  "CacheMissPercentage": 0.32,
  "CacheUsedPercentage": 0.07,
  "DiskIds": [
    "pci-0000:03:00.0-scsi-0:0:0:0",
    "pci-0000:04:00.0-scsi-0:1:0:0"
  ],
  "GatewayARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B"
}

POST DescribeCachediSCSIVolumes

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes

HEADERS

X-Amz-Target

BODY json

{
  "VolumeARNs": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"VolumeARNs\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:VolumeARNs ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"VolumeARNs\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"VolumeARNs\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"VolumeARNs\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes"

	payload := strings.NewReader("{\n  \"VolumeARNs\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "VolumeARNs": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"VolumeARNs\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"VolumeARNs\": \"\"\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  \"VolumeARNs\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"VolumeARNs\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  VolumeARNs: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {VolumeARNs: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"VolumeARNs":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "VolumeARNs": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"VolumeARNs\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({VolumeARNs: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {VolumeARNs: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  VolumeARNs: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {VolumeARNs: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"VolumeARNs":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"VolumeARNs": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"VolumeARNs\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes",
  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([
    'VolumeARNs' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes', [
  'body' => '{
  "VolumeARNs": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'VolumeARNs' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'VolumeARNs' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "VolumeARNs": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "VolumeARNs": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"VolumeARNs\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes"

payload = { "VolumeARNs": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes"

payload <- "{\n  \"VolumeARNs\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"VolumeARNs\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"VolumeARNs\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes";

    let payload = json!({"VolumeARNs": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "VolumeARNs": ""
}'

echo '{
  "VolumeARNs": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "VolumeARNs": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["VolumeARNs": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeCachediSCSIVolumes")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "CachediSCSIVolumes": [
    {
      "VolumeARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B/volume/vol-1122AABB",
      "VolumeId": "vol-1122AABB",
      "VolumeSizeInBytes": 1099511627776,
      "VolumeStatus": "AVAILABLE",
      "VolumeType": "CACHED iSCSI",
      "VolumeiSCSIAttributes": {
        "ChapEnabled": true,
        "LunNumber": 1,
        "NetworkInterfaceId": "10.243.43.207",
        "NetworkInterfacePort": 3260,
        "TargetARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B/target/iqn.1997-05.com.amazon:myvolume"
      }
    }
  ]
}

POST DescribeChapCredentials

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials

HEADERS

X-Amz-Target

BODY json

{
  "TargetARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"TargetARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:TargetARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TargetARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TargetARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TargetARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials"

	payload := strings.NewReader("{\n  \"TargetARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 21

{
  "TargetARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TargetARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TargetARN\": \"\"\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  \"TargetARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TargetARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TargetARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TargetARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TargetARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TargetARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TargetARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({TargetARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {TargetARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TargetARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TargetARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TargetARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"TargetARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TargetARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials",
  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([
    'TargetARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials', [
  'body' => '{
  "TargetARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TargetARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TargetARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TargetARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TargetARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TargetARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials"

payload = { "TargetARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials"

payload <- "{\n  \"TargetARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"TargetARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"TargetARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials";

    let payload = json!({"TargetARN": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "TargetARN": ""
}'

echo '{
  "TargetARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TargetARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["TargetARN": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeChapCredentials")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "ChapCredentials": [
    {
      "InitiatorName": "iqn.1991-05.com.microsoft:computername.domain.example.com",
      "SecretToAuthenticateInitiator": "111111111111",
      "SecretToAuthenticateTarget": "222222222222",
      "TargetARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B/target/iqn.1997-05.com.amazon:myvolume"
    }
  ]
}

POST DescribeFileSystemAssociations

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations

HEADERS

X-Amz-Target

BODY json

{
  "FileSystemAssociationARNList": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"FileSystemAssociationARNList\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:FileSystemAssociationARNList ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"FileSystemAssociationARNList\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"FileSystemAssociationARNList\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"FileSystemAssociationARNList\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations"

	payload := strings.NewReader("{\n  \"FileSystemAssociationARNList\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "FileSystemAssociationARNList": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"FileSystemAssociationARNList\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"FileSystemAssociationARNList\": \"\"\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  \"FileSystemAssociationARNList\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"FileSystemAssociationARNList\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  FileSystemAssociationARNList: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {FileSystemAssociationARNList: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FileSystemAssociationARNList":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "FileSystemAssociationARNList": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"FileSystemAssociationARNList\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({FileSystemAssociationARNList: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {FileSystemAssociationARNList: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  FileSystemAssociationARNList: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {FileSystemAssociationARNList: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FileSystemAssociationARNList":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"FileSystemAssociationARNList": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"FileSystemAssociationARNList\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations",
  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([
    'FileSystemAssociationARNList' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations', [
  'body' => '{
  "FileSystemAssociationARNList": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'FileSystemAssociationARNList' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'FileSystemAssociationARNList' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FileSystemAssociationARNList": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FileSystemAssociationARNList": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"FileSystemAssociationARNList\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations"

payload = { "FileSystemAssociationARNList": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations"

payload <- "{\n  \"FileSystemAssociationARNList\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"FileSystemAssociationARNList\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"FileSystemAssociationARNList\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations";

    let payload = json!({"FileSystemAssociationARNList": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "FileSystemAssociationARNList": ""
}'

echo '{
  "FileSystemAssociationARNList": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "FileSystemAssociationARNList": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["FileSystemAssociationARNList": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeFileSystemAssociations")! 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 DescribeGatewayInformation

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:GatewayARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "GatewayARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\"\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  \"GatewayARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation",
  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([
    'GatewayARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation', [
  'body' => '{
  "GatewayARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation"

payload = { "GatewayARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation"

payload <- "{\n  \"GatewayARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation";

    let payload = json!({"GatewayARN": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": ""
}'

echo '{
  "GatewayARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["GatewayARN": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeGatewayInformation")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "GatewayARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B",
  "GatewayId": "sgw-AABB1122",
  "GatewayName": "My_Gateway",
  "GatewayNetworkInterfaces": [
    {
      "Ipv4Address": "10.35.69.216"
    }
  ],
  "GatewayState": "STATE_RUNNING",
  "GatewayTimezone": "GMT-8:00",
  "GatewayType": "STORED",
  "LastSoftwareUpdate": "2016-01-02T16:00:00",
  "NextUpdateAvailabilityDate": "2017-01-02T16:00:00"
}

POST DescribeMaintenanceStartTime

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:GatewayARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "GatewayARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\"\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  \"GatewayARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime",
  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([
    'GatewayARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime', [
  'body' => '{
  "GatewayARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime"

payload = { "GatewayARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime"

payload <- "{\n  \"GatewayARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime";

    let payload = json!({"GatewayARN": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": ""
}'

echo '{
  "GatewayARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["GatewayARN": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeMaintenanceStartTime")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "DayOfWeek": 2,
  "GatewayARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B",
  "HourOfDay": 15,
  "MinuteOfHour": 35,
  "Timezone": "GMT+7:00"
}

POST DescribeNFSFileShares

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares

HEADERS

X-Amz-Target

BODY json

{
  "FileShareARNList": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"FileShareARNList\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:FileShareARNList ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"FileShareARNList\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"FileShareARNList\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"FileShareARNList\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares"

	payload := strings.NewReader("{\n  \"FileShareARNList\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 28

{
  "FileShareARNList": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"FileShareARNList\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"FileShareARNList\": \"\"\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  \"FileShareARNList\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"FileShareARNList\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  FileShareARNList: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {FileShareARNList: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FileShareARNList":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "FileShareARNList": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"FileShareARNList\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({FileShareARNList: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {FileShareARNList: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  FileShareARNList: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {FileShareARNList: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FileShareARNList":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"FileShareARNList": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"FileShareARNList\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares",
  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([
    'FileShareARNList' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares', [
  'body' => '{
  "FileShareARNList": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'FileShareARNList' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'FileShareARNList' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FileShareARNList": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FileShareARNList": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"FileShareARNList\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares"

payload = { "FileShareARNList": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares"

payload <- "{\n  \"FileShareARNList\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"FileShareARNList\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"FileShareARNList\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares";

    let payload = json!({"FileShareARNList": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "FileShareARNList": ""
}'

echo '{
  "FileShareARNList": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "FileShareARNList": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["FileShareARNList": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeNFSFileShares")! 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 DescribeSMBFileShares

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares

HEADERS

X-Amz-Target

BODY json

{
  "FileShareARNList": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"FileShareARNList\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:FileShareARNList ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"FileShareARNList\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"FileShareARNList\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"FileShareARNList\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares"

	payload := strings.NewReader("{\n  \"FileShareARNList\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 28

{
  "FileShareARNList": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"FileShareARNList\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"FileShareARNList\": \"\"\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  \"FileShareARNList\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"FileShareARNList\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  FileShareARNList: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {FileShareARNList: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FileShareARNList":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "FileShareARNList": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"FileShareARNList\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({FileShareARNList: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {FileShareARNList: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  FileShareARNList: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {FileShareARNList: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FileShareARNList":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"FileShareARNList": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"FileShareARNList\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares",
  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([
    'FileShareARNList' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares', [
  'body' => '{
  "FileShareARNList": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'FileShareARNList' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'FileShareARNList' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FileShareARNList": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FileShareARNList": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"FileShareARNList\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares"

payload = { "FileShareARNList": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares"

payload <- "{\n  \"FileShareARNList\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"FileShareARNList\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"FileShareARNList\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares";

    let payload = json!({"FileShareARNList": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "FileShareARNList": ""
}'

echo '{
  "FileShareARNList": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "FileShareARNList": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["FileShareARNList": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBFileShares")! 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 DescribeSMBSettings

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:GatewayARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "GatewayARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\"\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  \"GatewayARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings",
  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([
    'GatewayARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings', [
  'body' => '{
  "GatewayARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings"

payload = { "GatewayARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings"

payload <- "{\n  \"GatewayARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings";

    let payload = json!({"GatewayARN": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": ""
}'

echo '{
  "GatewayARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["GatewayARN": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSMBSettings")! 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 DescribeSnapshotSchedule

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule

HEADERS

X-Amz-Target

BODY json

{
  "VolumeARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"VolumeARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:VolumeARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"VolumeARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"VolumeARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"VolumeARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule"

	payload := strings.NewReader("{\n  \"VolumeARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 21

{
  "VolumeARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"VolumeARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"VolumeARN\": \"\"\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  \"VolumeARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"VolumeARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  VolumeARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {VolumeARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"VolumeARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "VolumeARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"VolumeARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({VolumeARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {VolumeARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  VolumeARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {VolumeARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"VolumeARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"VolumeARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"VolumeARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule",
  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([
    'VolumeARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule', [
  'body' => '{
  "VolumeARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'VolumeARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'VolumeARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "VolumeARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "VolumeARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"VolumeARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule"

payload = { "VolumeARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule"

payload <- "{\n  \"VolumeARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"VolumeARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"VolumeARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule";

    let payload = json!({"VolumeARN": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "VolumeARN": ""
}'

echo '{
  "VolumeARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "VolumeARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["VolumeARN": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeSnapshotSchedule")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "Description": "sgw-AABB1122:vol-AABB1122:Schedule",
  "RecurrenceInHours": 24,
  "StartAt": 6,
  "Timezone": "GMT+7:00",
  "VolumeARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B/volume/vol-1122AABB"
}

POST DescribeStorediSCSIVolumes

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes

HEADERS

X-Amz-Target

BODY json

{
  "VolumeARNs": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"VolumeARNs\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:VolumeARNs ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"VolumeARNs\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"VolumeARNs\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"VolumeARNs\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes"

	payload := strings.NewReader("{\n  \"VolumeARNs\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "VolumeARNs": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"VolumeARNs\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"VolumeARNs\": \"\"\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  \"VolumeARNs\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"VolumeARNs\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  VolumeARNs: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {VolumeARNs: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"VolumeARNs":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "VolumeARNs": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"VolumeARNs\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({VolumeARNs: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {VolumeARNs: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  VolumeARNs: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {VolumeARNs: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"VolumeARNs":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"VolumeARNs": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"VolumeARNs\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes",
  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([
    'VolumeARNs' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes', [
  'body' => '{
  "VolumeARNs": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'VolumeARNs' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'VolumeARNs' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "VolumeARNs": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "VolumeARNs": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"VolumeARNs\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes"

payload = { "VolumeARNs": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes"

payload <- "{\n  \"VolumeARNs\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"VolumeARNs\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"VolumeARNs\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes";

    let payload = json!({"VolumeARNs": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "VolumeARNs": ""
}'

echo '{
  "VolumeARNs": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "VolumeARNs": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["VolumeARNs": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeStorediSCSIVolumes")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "StorediSCSIVolumes": [
    {
      "PreservedExistingData": false,
      "VolumeARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B/volume/vol-1122AABB",
      "VolumeDiskId": "pci-0000:03:00.0-scsi-0:0:0:0",
      "VolumeId": "vol-1122AABB",
      "VolumeProgress": 23.7,
      "VolumeSizeInBytes": 1099511627776,
      "VolumeStatus": "BOOTSTRAPPING",
      "VolumeiSCSIAttributes": {
        "ChapEnabled": true,
        "NetworkInterfaceId": "10.243.43.207",
        "NetworkInterfacePort": 3260,
        "TargetARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B/target/iqn.1997-05.com.amazon:myvolume"
      }
    }
  ]
}

POST DescribeTapeArchives

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives

HEADERS

X-Amz-Target

BODY json

{
  "TapeARNs": "",
  "Marker": "",
  "Limit": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:TapeARNs ""
                                                                                                                     :Marker ""
                                                                                                                     :Limit ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives"

	payload := strings.NewReader("{\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 51

{
  "TapeARNs": "",
  "Marker": "",
  "Limit": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TapeARNs: '',
  Marker: '',
  Limit: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TapeARNs: '', Marker: '', Limit: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TapeARNs":"","Marker":"","Limit":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TapeARNs": "",\n  "Marker": "",\n  "Limit": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({TapeARNs: '', Marker: '', Limit: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {TapeARNs: '', Marker: '', Limit: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TapeARNs: '',
  Marker: '',
  Limit: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TapeARNs: '', Marker: '', Limit: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TapeARNs":"","Marker":"","Limit":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"TapeARNs": @"",
                              @"Marker": @"",
                              @"Limit": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives",
  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([
    'TapeARNs' => '',
    'Marker' => '',
    'Limit' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives', [
  'body' => '{
  "TapeARNs": "",
  "Marker": "",
  "Limit": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TapeARNs' => '',
  'Marker' => '',
  'Limit' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TapeARNs' => '',
  'Marker' => '',
  'Limit' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TapeARNs": "",
  "Marker": "",
  "Limit": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TapeARNs": "",
  "Marker": "",
  "Limit": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives"

payload = {
    "TapeARNs": "",
    "Marker": "",
    "Limit": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives"

payload <- "{\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives";

    let payload = json!({
        "TapeARNs": "",
        "Marker": "",
        "Limit": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "TapeARNs": "",
  "Marker": "",
  "Limit": ""
}'

echo '{
  "TapeARNs": "",
  "Marker": "",
  "Limit": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TapeARNs": "",\n  "Marker": "",\n  "Limit": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TapeARNs": "",
  "Marker": "",
  "Limit": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeArchives")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "Marker": "1",
  "TapeArchives": [
    {
      "CompletionTime": "2016-12-16T13:50Z",
      "TapeARN": "arn:aws:storagegateway:us-east-1:999999999:tape/AM08A1AD",
      "TapeBarcode": "AM08A1AD",
      "TapeSizeInBytes": 107374182400,
      "TapeStatus": "ARCHIVED"
    },
    {
      "CompletionTime": "2016-12-16T13:59Z",
      "TapeARN": "arn:aws:storagegateway:us-east-1:999999999:tape/AMZN01A2A4",
      "TapeBarcode": "AMZN01A2A4",
      "TapeSizeInBytes": 429496729600,
      "TapeStatus": "ARCHIVED"
    }
  ]
}

POST DescribeTapeRecoveryPoints

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "Marker": "",
  "Limit": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:GatewayARN ""
                                                                                                                           :Marker ""
                                                                                                                           :Limit ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 53

{
  "GatewayARN": "",
  "Marker": "",
  "Limit": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  Marker: '',
  Limit: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', Marker: '', Limit: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","Marker":"","Limit":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "Marker": "",\n  "Limit": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: '', Marker: '', Limit: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: '', Marker: '', Limit: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: '',
  Marker: '',
  Limit: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', Marker: '', Limit: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","Marker":"","Limit":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"Marker": @"",
                              @"Limit": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints",
  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([
    'GatewayARN' => '',
    'Marker' => '',
    'Limit' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints', [
  'body' => '{
  "GatewayARN": "",
  "Marker": "",
  "Limit": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => '',
  'Marker' => '',
  'Limit' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => '',
  'Marker' => '',
  'Limit' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "Marker": "",
  "Limit": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "Marker": "",
  "Limit": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints"

payload = {
    "GatewayARN": "",
    "Marker": "",
    "Limit": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints";

    let payload = json!({
        "GatewayARN": "",
        "Marker": "",
        "Limit": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "Marker": "",
  "Limit": ""
}'

echo '{
  "GatewayARN": "",
  "Marker": "",
  "Limit": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "Marker": "",\n  "Limit": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "Marker": "",
  "Limit": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapeRecoveryPoints")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "GatewayARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B",
  "Marker": "1",
  "TapeRecoveryPointInfos": [
    {
      "TapeARN": "arn:aws:storagegateway:us-east-1:999999999:tape/AMZN01A2A4",
      "TapeRecoveryPointTime": "2016-12-16T13:50Z",
      "TapeSizeInBytes": 1471550497,
      "TapeStatus": "AVAILABLE"
    }
  ]
}

POST DescribeTapes

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "TapeARNs": "",
  "Marker": "",
  "Limit": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\",\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes" {:headers {:x-amz-target ""}
                                                                                                :content-type :json
                                                                                                :form-params {:GatewayARN ""
                                                                                                              :TapeARNs ""
                                                                                                              :Marker ""
                                                                                                              :Limit ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 71

{
  "GatewayARN": "",
  "TapeARNs": "",
  "Marker": "",
  "Limit": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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  \"GatewayARN\": \"\",\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  TapeARNs: '',
  Marker: '',
  Limit: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', TapeARNs: '', Marker: '', Limit: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","TapeARNs":"","Marker":"","Limit":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "TapeARNs": "",\n  "Marker": "",\n  "Limit": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: '', TapeARNs: '', Marker: '', Limit: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: '', TapeARNs: '', Marker: '', Limit: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: '',
  TapeARNs: '',
  Marker: '',
  Limit: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', TapeARNs: '', Marker: '', Limit: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","TapeARNs":"","Marker":"","Limit":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"TapeARNs": @"",
                              @"Marker": @"",
                              @"Limit": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes",
  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([
    'GatewayARN' => '',
    'TapeARNs' => '',
    'Marker' => '',
    'Limit' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes', [
  'body' => '{
  "GatewayARN": "",
  "TapeARNs": "",
  "Marker": "",
  "Limit": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => '',
  'TapeARNs' => '',
  'Marker' => '',
  'Limit' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => '',
  'TapeARNs' => '',
  'Marker' => '',
  'Limit' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "TapeARNs": "",
  "Marker": "",
  "Limit": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "TapeARNs": "",
  "Marker": "",
  "Limit": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\",\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes"

payload = {
    "GatewayARN": "",
    "TapeARNs": "",
    "Marker": "",
    "Limit": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"TapeARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes";

    let payload = json!({
        "GatewayARN": "",
        "TapeARNs": "",
        "Marker": "",
        "Limit": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "TapeARNs": "",
  "Marker": "",
  "Limit": ""
}'

echo '{
  "GatewayARN": "",
  "TapeARNs": "",
  "Marker": "",
  "Limit": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "TapeARNs": "",\n  "Marker": "",\n  "Limit": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "TapeARNs": "",
  "Marker": "",
  "Limit": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeTapes")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "Marker": "1",
  "Tapes": [
    {
      "TapeARN": "arn:aws:storagegateway:us-east-1:999999999999:tape/TEST04A2A1",
      "TapeBarcode": "TEST04A2A1",
      "TapeSizeInBytes": 107374182400,
      "TapeStatus": "AVAILABLE"
    },
    {
      "TapeARN": "arn:aws:storagegateway:us-east-1:999999999999:tape/TEST05A2A0",
      "TapeBarcode": "TEST05A2A0",
      "TapeSizeInBytes": 107374182400,
      "TapeStatus": "AVAILABLE"
    }
  ]
}

POST DescribeUploadBuffer

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:GatewayARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "GatewayARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\"\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  \"GatewayARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer",
  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([
    'GatewayARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer', [
  'body' => '{
  "GatewayARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer"

payload = { "GatewayARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer"

payload <- "{\n  \"GatewayARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer";

    let payload = json!({"GatewayARN": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": ""
}'

echo '{
  "GatewayARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["GatewayARN": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeUploadBuffer")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "DiskIds": [
    "pci-0000:03:00.0-scsi-0:0:0:0",
    "pci-0000:04:00.0-scsi-0:1:0:0"
  ],
  "GatewayARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B",
  "UploadBufferAllocatedInBytes": 161061273600,
  "UploadBufferUsedInBytes": 0
}

POST DescribeVTLDevices

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "VTLDeviceARNs": "",
  "Marker": "",
  "Limit": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\",\n  \"VTLDeviceARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:GatewayARN ""
                                                                                                                   :VTLDeviceARNs ""
                                                                                                                   :Marker ""
                                                                                                                   :Limit ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"VTLDeviceARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"VTLDeviceARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"VTLDeviceARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"VTLDeviceARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 76

{
  "GatewayARN": "",
  "VTLDeviceARNs": "",
  "Marker": "",
  "Limit": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"VTLDeviceARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"VTLDeviceARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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  \"GatewayARN\": \"\",\n  \"VTLDeviceARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"VTLDeviceARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  VTLDeviceARNs: '',
  Marker: '',
  Limit: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', VTLDeviceARNs: '', Marker: '', Limit: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","VTLDeviceARNs":"","Marker":"","Limit":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "VTLDeviceARNs": "",\n  "Marker": "",\n  "Limit": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"VTLDeviceARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: '', VTLDeviceARNs: '', Marker: '', Limit: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: '', VTLDeviceARNs: '', Marker: '', Limit: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: '',
  VTLDeviceARNs: '',
  Marker: '',
  Limit: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', VTLDeviceARNs: '', Marker: '', Limit: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","VTLDeviceARNs":"","Marker":"","Limit":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"VTLDeviceARNs": @"",
                              @"Marker": @"",
                              @"Limit": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"VTLDeviceARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices",
  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([
    'GatewayARN' => '',
    'VTLDeviceARNs' => '',
    'Marker' => '',
    'Limit' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices', [
  'body' => '{
  "GatewayARN": "",
  "VTLDeviceARNs": "",
  "Marker": "",
  "Limit": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => '',
  'VTLDeviceARNs' => '',
  'Marker' => '',
  'Limit' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => '',
  'VTLDeviceARNs' => '',
  'Marker' => '',
  'Limit' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "VTLDeviceARNs": "",
  "Marker": "",
  "Limit": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "VTLDeviceARNs": "",
  "Marker": "",
  "Limit": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\",\n  \"VTLDeviceARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices"

payload = {
    "GatewayARN": "",
    "VTLDeviceARNs": "",
    "Marker": "",
    "Limit": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"VTLDeviceARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"VTLDeviceARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"VTLDeviceARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices";

    let payload = json!({
        "GatewayARN": "",
        "VTLDeviceARNs": "",
        "Marker": "",
        "Limit": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "VTLDeviceARNs": "",
  "Marker": "",
  "Limit": ""
}'

echo '{
  "GatewayARN": "",
  "VTLDeviceARNs": "",
  "Marker": "",
  "Limit": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "VTLDeviceARNs": "",\n  "Marker": "",\n  "Limit": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "VTLDeviceARNs": "",
  "Marker": "",
  "Limit": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeVTLDevices")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "GatewayARN": "arn:aws:storagegateway:us-east-1:999999999999:gateway/sgw-12A3456B",
  "Marker": "1",
  "VTLDevices": [
    {
      "DeviceiSCSIAttributes": {
        "ChapEnabled": false,
        "NetworkInterfaceId": "10.243.43.207",
        "NetworkInterfacePort": 3260,
        "TargetARN": "arn:aws:storagegateway:us-east-1:999999999999:gateway/sgw-12A3456B/target/iqn.1997-05.com.amazon:sgw-1fad4876-mediachanger"
      },
      "VTLDeviceARN": "arn:aws:storagegateway:us-east-1:999999999999:gateway/sgw-12A3456B/device/AMZN_SGW-1FAD4876_MEDIACHANGER_00001",
      "VTLDeviceProductIdentifier": "L700",
      "VTLDeviceType": "Medium Changer",
      "VTLDeviceVendor": "STK"
    },
    {
      "DeviceiSCSIAttributes": {
        "ChapEnabled": false,
        "NetworkInterfaceId": "10.243.43.209",
        "NetworkInterfacePort": 3260,
        "TargetARN": "arn:aws:storagegateway:us-east-1:999999999999:gateway/sgw-12A3456B/target/iqn.1997-05.com.amazon:sgw-1fad4876-tapedrive-01"
      },
      "VTLDeviceARN": "arn:aws:storagegateway:us-east-1:999999999999:gateway/sgw-12A3456B/device/AMZN_SGW-1FAD4876_TAPEDRIVE_00001",
      "VTLDeviceProductIdentifier": "ULT3580-TD5",
      "VTLDeviceType": "Tape Drive",
      "VTLDeviceVendor": "IBM"
    },
    {
      "DeviceiSCSIAttributes": {
        "ChapEnabled": false,
        "NetworkInterfaceId": "10.243.43.209",
        "NetworkInterfacePort": 3260,
        "TargetARN": "arn:aws:storagegateway:us-east-1:999999999999:gateway/sgw-12A3456B/target/iqn.1997-05.com.amazon:sgw-1fad4876-tapedrive-02"
      },
      "VTLDeviceARN": "arn:aws:storagegateway:us-east-1:999999999999:gateway/sgw-12A3456B/device/AMZN_SGW-1FAD4876_TAPEDRIVE_00002",
      "VTLDeviceProductIdentifier": "ULT3580-TD5",
      "VTLDeviceType": "Tape Drive",
      "VTLDeviceVendor": "IBM"
    }
  ]
}

POST DescribeWorkingStorage

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:GatewayARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "GatewayARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\"\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  \"GatewayARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage",
  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([
    'GatewayARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage', [
  'body' => '{
  "GatewayARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage"

payload = { "GatewayARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage"

payload <- "{\n  \"GatewayARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage";

    let payload = json!({"GatewayARN": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": ""
}'

echo '{
  "GatewayARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["GatewayARN": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DescribeWorkingStorage")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "DiskIds": [
    "pci-0000:03:00.0-scsi-0:0:0:0",
    "pci-0000:03:00.0-scsi-0:0:1:0"
  ],
  "GatewayARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B",
  "WorkingStorageAllocatedInBytes": 2199023255552,
  "WorkingStorageUsedInBytes": 789207040
}

POST DetachVolume

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume

HEADERS

X-Amz-Target

BODY json

{
  "VolumeARN": "",
  "ForceDetach": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"VolumeARN\": \"\",\n  \"ForceDetach\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume" {:headers {:x-amz-target ""}
                                                                                               :content-type :json
                                                                                               :form-params {:VolumeARN ""
                                                                                                             :ForceDetach ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"VolumeARN\": \"\",\n  \"ForceDetach\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"VolumeARN\": \"\",\n  \"ForceDetach\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"VolumeARN\": \"\",\n  \"ForceDetach\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume"

	payload := strings.NewReader("{\n  \"VolumeARN\": \"\",\n  \"ForceDetach\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 42

{
  "VolumeARN": "",
  "ForceDetach": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"VolumeARN\": \"\",\n  \"ForceDetach\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"VolumeARN\": \"\",\n  \"ForceDetach\": \"\"\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  \"VolumeARN\": \"\",\n  \"ForceDetach\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"VolumeARN\": \"\",\n  \"ForceDetach\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  VolumeARN: '',
  ForceDetach: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {VolumeARN: '', ForceDetach: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"VolumeARN":"","ForceDetach":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "VolumeARN": "",\n  "ForceDetach": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"VolumeARN\": \"\",\n  \"ForceDetach\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({VolumeARN: '', ForceDetach: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {VolumeARN: '', ForceDetach: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  VolumeARN: '',
  ForceDetach: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {VolumeARN: '', ForceDetach: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"VolumeARN":"","ForceDetach":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"VolumeARN": @"",
                              @"ForceDetach": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"VolumeARN\": \"\",\n  \"ForceDetach\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume",
  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([
    'VolumeARN' => '',
    'ForceDetach' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume', [
  'body' => '{
  "VolumeARN": "",
  "ForceDetach": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'VolumeARN' => '',
  'ForceDetach' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'VolumeARN' => '',
  'ForceDetach' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "VolumeARN": "",
  "ForceDetach": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "VolumeARN": "",
  "ForceDetach": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"VolumeARN\": \"\",\n  \"ForceDetach\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume"

payload = {
    "VolumeARN": "",
    "ForceDetach": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume"

payload <- "{\n  \"VolumeARN\": \"\",\n  \"ForceDetach\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"VolumeARN\": \"\",\n  \"ForceDetach\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"VolumeARN\": \"\",\n  \"ForceDetach\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume";

    let payload = json!({
        "VolumeARN": "",
        "ForceDetach": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "VolumeARN": "",
  "ForceDetach": ""
}'

echo '{
  "VolumeARN": "",
  "ForceDetach": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "VolumeARN": "",\n  "ForceDetach": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "VolumeARN": "",
  "ForceDetach": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DetachVolume")! 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 DisableGateway

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway" {:headers {:x-amz-target ""}
                                                                                                 :content-type :json
                                                                                                 :form-params {:GatewayARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "GatewayARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\"\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  \"GatewayARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway",
  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([
    'GatewayARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway', [
  'body' => '{
  "GatewayARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway"

payload = { "GatewayARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway"

payload <- "{\n  \"GatewayARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway";

    let payload = json!({"GatewayARN": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": ""
}'

echo '{
  "GatewayARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["GatewayARN": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisableGateway")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "GatewayARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B"
}

POST DisassociateFileSystem

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem

HEADERS

X-Amz-Target

BODY json

{
  "FileSystemAssociationARN": "",
  "ForceDelete": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"FileSystemAssociationARN\": \"\",\n  \"ForceDelete\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:FileSystemAssociationARN ""
                                                                                                                       :ForceDelete ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"FileSystemAssociationARN\": \"\",\n  \"ForceDelete\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"FileSystemAssociationARN\": \"\",\n  \"ForceDelete\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"FileSystemAssociationARN\": \"\",\n  \"ForceDelete\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem"

	payload := strings.NewReader("{\n  \"FileSystemAssociationARN\": \"\",\n  \"ForceDelete\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 57

{
  "FileSystemAssociationARN": "",
  "ForceDelete": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"FileSystemAssociationARN\": \"\",\n  \"ForceDelete\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"FileSystemAssociationARN\": \"\",\n  \"ForceDelete\": \"\"\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  \"FileSystemAssociationARN\": \"\",\n  \"ForceDelete\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"FileSystemAssociationARN\": \"\",\n  \"ForceDelete\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  FileSystemAssociationARN: '',
  ForceDelete: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {FileSystemAssociationARN: '', ForceDelete: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FileSystemAssociationARN":"","ForceDelete":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "FileSystemAssociationARN": "",\n  "ForceDelete": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"FileSystemAssociationARN\": \"\",\n  \"ForceDelete\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({FileSystemAssociationARN: '', ForceDelete: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {FileSystemAssociationARN: '', ForceDelete: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  FileSystemAssociationARN: '',
  ForceDelete: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {FileSystemAssociationARN: '', ForceDelete: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FileSystemAssociationARN":"","ForceDelete":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"FileSystemAssociationARN": @"",
                              @"ForceDelete": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"FileSystemAssociationARN\": \"\",\n  \"ForceDelete\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem",
  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([
    'FileSystemAssociationARN' => '',
    'ForceDelete' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem', [
  'body' => '{
  "FileSystemAssociationARN": "",
  "ForceDelete": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'FileSystemAssociationARN' => '',
  'ForceDelete' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'FileSystemAssociationARN' => '',
  'ForceDelete' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FileSystemAssociationARN": "",
  "ForceDelete": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FileSystemAssociationARN": "",
  "ForceDelete": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"FileSystemAssociationARN\": \"\",\n  \"ForceDelete\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem"

payload = {
    "FileSystemAssociationARN": "",
    "ForceDelete": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem"

payload <- "{\n  \"FileSystemAssociationARN\": \"\",\n  \"ForceDelete\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"FileSystemAssociationARN\": \"\",\n  \"ForceDelete\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"FileSystemAssociationARN\": \"\",\n  \"ForceDelete\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem";

    let payload = json!({
        "FileSystemAssociationARN": "",
        "ForceDelete": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "FileSystemAssociationARN": "",
  "ForceDelete": ""
}'

echo '{
  "FileSystemAssociationARN": "",
  "ForceDelete": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "FileSystemAssociationARN": "",\n  "ForceDelete": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "FileSystemAssociationARN": "",
  "ForceDelete": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.DisassociateFileSystem")! 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 JoinDomain

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "DomainName": "",
  "OrganizationalUnit": "",
  "DomainControllers": "",
  "TimeoutInSeconds": "",
  "UserName": "",
  "Password": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\",\n  \"DomainName\": \"\",\n  \"OrganizationalUnit\": \"\",\n  \"DomainControllers\": \"\",\n  \"TimeoutInSeconds\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain" {:headers {:x-amz-target ""}
                                                                                             :content-type :json
                                                                                             :form-params {:GatewayARN ""
                                                                                                           :DomainName ""
                                                                                                           :OrganizationalUnit ""
                                                                                                           :DomainControllers ""
                                                                                                           :TimeoutInSeconds ""
                                                                                                           :UserName ""
                                                                                                           :Password ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"DomainName\": \"\",\n  \"OrganizationalUnit\": \"\",\n  \"DomainControllers\": \"\",\n  \"TimeoutInSeconds\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"DomainName\": \"\",\n  \"OrganizationalUnit\": \"\",\n  \"DomainControllers\": \"\",\n  \"TimeoutInSeconds\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"DomainName\": \"\",\n  \"OrganizationalUnit\": \"\",\n  \"DomainControllers\": \"\",\n  \"TimeoutInSeconds\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"DomainName\": \"\",\n  \"OrganizationalUnit\": \"\",\n  \"DomainControllers\": \"\",\n  \"TimeoutInSeconds\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 159

{
  "GatewayARN": "",
  "DomainName": "",
  "OrganizationalUnit": "",
  "DomainControllers": "",
  "TimeoutInSeconds": "",
  "UserName": "",
  "Password": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"DomainName\": \"\",\n  \"OrganizationalUnit\": \"\",\n  \"DomainControllers\": \"\",\n  \"TimeoutInSeconds\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"DomainName\": \"\",\n  \"OrganizationalUnit\": \"\",\n  \"DomainControllers\": \"\",\n  \"TimeoutInSeconds\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\"\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  \"GatewayARN\": \"\",\n  \"DomainName\": \"\",\n  \"OrganizationalUnit\": \"\",\n  \"DomainControllers\": \"\",\n  \"TimeoutInSeconds\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"DomainName\": \"\",\n  \"OrganizationalUnit\": \"\",\n  \"DomainControllers\": \"\",\n  \"TimeoutInSeconds\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  DomainName: '',
  OrganizationalUnit: '',
  DomainControllers: '',
  TimeoutInSeconds: '',
  UserName: '',
  Password: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    GatewayARN: '',
    DomainName: '',
    OrganizationalUnit: '',
    DomainControllers: '',
    TimeoutInSeconds: '',
    UserName: '',
    Password: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","DomainName":"","OrganizationalUnit":"","DomainControllers":"","TimeoutInSeconds":"","UserName":"","Password":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "DomainName": "",\n  "OrganizationalUnit": "",\n  "DomainControllers": "",\n  "TimeoutInSeconds": "",\n  "UserName": "",\n  "Password": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"DomainName\": \"\",\n  \"OrganizationalUnit\": \"\",\n  \"DomainControllers\": \"\",\n  \"TimeoutInSeconds\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({
  GatewayARN: '',
  DomainName: '',
  OrganizationalUnit: '',
  DomainControllers: '',
  TimeoutInSeconds: '',
  UserName: '',
  Password: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    GatewayARN: '',
    DomainName: '',
    OrganizationalUnit: '',
    DomainControllers: '',
    TimeoutInSeconds: '',
    UserName: '',
    Password: ''
  },
  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}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: '',
  DomainName: '',
  OrganizationalUnit: '',
  DomainControllers: '',
  TimeoutInSeconds: '',
  UserName: '',
  Password: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    GatewayARN: '',
    DomainName: '',
    OrganizationalUnit: '',
    DomainControllers: '',
    TimeoutInSeconds: '',
    UserName: '',
    Password: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","DomainName":"","OrganizationalUnit":"","DomainControllers":"","TimeoutInSeconds":"","UserName":"","Password":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"DomainName": @"",
                              @"OrganizationalUnit": @"",
                              @"DomainControllers": @"",
                              @"TimeoutInSeconds": @"",
                              @"UserName": @"",
                              @"Password": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"DomainName\": \"\",\n  \"OrganizationalUnit\": \"\",\n  \"DomainControllers\": \"\",\n  \"TimeoutInSeconds\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain",
  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([
    'GatewayARN' => '',
    'DomainName' => '',
    'OrganizationalUnit' => '',
    'DomainControllers' => '',
    'TimeoutInSeconds' => '',
    'UserName' => '',
    'Password' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain', [
  'body' => '{
  "GatewayARN": "",
  "DomainName": "",
  "OrganizationalUnit": "",
  "DomainControllers": "",
  "TimeoutInSeconds": "",
  "UserName": "",
  "Password": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => '',
  'DomainName' => '',
  'OrganizationalUnit' => '',
  'DomainControllers' => '',
  'TimeoutInSeconds' => '',
  'UserName' => '',
  'Password' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => '',
  'DomainName' => '',
  'OrganizationalUnit' => '',
  'DomainControllers' => '',
  'TimeoutInSeconds' => '',
  'UserName' => '',
  'Password' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "DomainName": "",
  "OrganizationalUnit": "",
  "DomainControllers": "",
  "TimeoutInSeconds": "",
  "UserName": "",
  "Password": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "DomainName": "",
  "OrganizationalUnit": "",
  "DomainControllers": "",
  "TimeoutInSeconds": "",
  "UserName": "",
  "Password": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\",\n  \"DomainName\": \"\",\n  \"OrganizationalUnit\": \"\",\n  \"DomainControllers\": \"\",\n  \"TimeoutInSeconds\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain"

payload = {
    "GatewayARN": "",
    "DomainName": "",
    "OrganizationalUnit": "",
    "DomainControllers": "",
    "TimeoutInSeconds": "",
    "UserName": "",
    "Password": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"DomainName\": \"\",\n  \"OrganizationalUnit\": \"\",\n  \"DomainControllers\": \"\",\n  \"TimeoutInSeconds\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"DomainName\": \"\",\n  \"OrganizationalUnit\": \"\",\n  \"DomainControllers\": \"\",\n  \"TimeoutInSeconds\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"DomainName\": \"\",\n  \"OrganizationalUnit\": \"\",\n  \"DomainControllers\": \"\",\n  \"TimeoutInSeconds\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain";

    let payload = json!({
        "GatewayARN": "",
        "DomainName": "",
        "OrganizationalUnit": "",
        "DomainControllers": "",
        "TimeoutInSeconds": "",
        "UserName": "",
        "Password": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "DomainName": "",
  "OrganizationalUnit": "",
  "DomainControllers": "",
  "TimeoutInSeconds": "",
  "UserName": "",
  "Password": ""
}'

echo '{
  "GatewayARN": "",
  "DomainName": "",
  "OrganizationalUnit": "",
  "DomainControllers": "",
  "TimeoutInSeconds": "",
  "UserName": "",
  "Password": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "DomainName": "",\n  "OrganizationalUnit": "",\n  "DomainControllers": "",\n  "TimeoutInSeconds": "",\n  "UserName": "",\n  "Password": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "DomainName": "",
  "OrganizationalUnit": "",
  "DomainControllers": "",
  "TimeoutInSeconds": "",
  "UserName": "",
  "Password": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.JoinDomain")! 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 ListAutomaticTapeCreationPolicies

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies" {:headers {:x-amz-target ""}
                                                                                                                    :content-type :json
                                                                                                                    :form-params {:GatewayARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "GatewayARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\"\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  \"GatewayARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies",
  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([
    'GatewayARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies', [
  'body' => '{
  "GatewayARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies"

payload = { "GatewayARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies"

payload <- "{\n  \"GatewayARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies";

    let payload = json!({"GatewayARN": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": ""
}'

echo '{
  "GatewayARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["GatewayARN": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListAutomaticTapeCreationPolicies")! 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 ListFileShares

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "Limit": "",
  "Marker": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares" {:headers {:x-amz-target ""}
                                                                                                 :content-type :json
                                                                                                 :form-params {:GatewayARN ""
                                                                                                               :Limit ""
                                                                                                               :Marker ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 53

{
  "GatewayARN": "",
  "Limit": "",
  "Marker": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\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  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  Limit: '',
  Marker: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', Limit: '', Marker: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","Limit":"","Marker":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "Limit": "",\n  "Marker": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: '', Limit: '', Marker: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: '', Limit: '', Marker: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: '',
  Limit: '',
  Marker: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', Limit: '', Marker: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","Limit":"","Marker":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"Limit": @"",
                              @"Marker": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares",
  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([
    'GatewayARN' => '',
    'Limit' => '',
    'Marker' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares', [
  'body' => '{
  "GatewayARN": "",
  "Limit": "",
  "Marker": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => '',
  'Limit' => '',
  'Marker' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => '',
  'Limit' => '',
  'Marker' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "Limit": "",
  "Marker": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "Limit": "",
  "Marker": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares"

payload = {
    "GatewayARN": "",
    "Limit": "",
    "Marker": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares";

    let payload = json!({
        "GatewayARN": "",
        "Limit": "",
        "Marker": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "Limit": "",
  "Marker": ""
}'

echo '{
  "GatewayARN": "",
  "Limit": "",
  "Marker": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "Limit": "",\n  "Marker": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "Limit": "",
  "Marker": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileShares")! 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 ListFileSystemAssociations

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "Limit": "",
  "Marker": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:GatewayARN ""
                                                                                                                           :Limit ""
                                                                                                                           :Marker ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 53

{
  "GatewayARN": "",
  "Limit": "",
  "Marker": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\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  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  Limit: '',
  Marker: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', Limit: '', Marker: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","Limit":"","Marker":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "Limit": "",\n  "Marker": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: '', Limit: '', Marker: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: '', Limit: '', Marker: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: '',
  Limit: '',
  Marker: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', Limit: '', Marker: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","Limit":"","Marker":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"Limit": @"",
                              @"Marker": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations",
  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([
    'GatewayARN' => '',
    'Limit' => '',
    'Marker' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations', [
  'body' => '{
  "GatewayARN": "",
  "Limit": "",
  "Marker": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => '',
  'Limit' => '',
  'Marker' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => '',
  'Limit' => '',
  'Marker' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "Limit": "",
  "Marker": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "Limit": "",
  "Marker": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations"

payload = {
    "GatewayARN": "",
    "Limit": "",
    "Marker": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"Limit\": \"\",\n  \"Marker\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations";

    let payload = json!({
        "GatewayARN": "",
        "Limit": "",
        "Marker": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "Limit": "",
  "Marker": ""
}'

echo '{
  "GatewayARN": "",
  "Limit": "",
  "Marker": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "Limit": "",\n  "Marker": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "Limit": "",
  "Marker": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListFileSystemAssociations")! 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 ListGateways

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways

HEADERS

X-Amz-Target

BODY json

{
  "Marker": "",
  "Limit": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways" {:headers {:x-amz-target ""}
                                                                                               :content-type :json
                                                                                               :form-params {:Marker ""
                                                                                                             :Limit ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.ListGateways"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.ListGateways");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways"

	payload := strings.NewReader("{\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 33

{
  "Marker": "",
  "Limit": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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  \"Marker\": \"\",\n  \"Limit\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Marker: '',
  Limit: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Marker: '', Limit: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Marker":"","Limit":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.ListGateways',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Marker": "",\n  "Limit": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({Marker: '', Limit: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Marker: '', Limit: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.ListGateways');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Marker: '',
  Limit: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.ListGateways',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Marker: '', Limit: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Marker":"","Limit":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Marker": @"",
                              @"Limit": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.ListGateways" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways",
  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([
    'Marker' => '',
    'Limit' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways', [
  'body' => '{
  "Marker": "",
  "Limit": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Marker' => '',
  'Limit' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Marker' => '',
  'Limit' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Marker": "",
  "Limit": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Marker": "",
  "Limit": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways"

payload = {
    "Marker": "",
    "Limit": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways"

payload <- "{\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways";

    let payload = json!({
        "Marker": "",
        "Limit": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.ListGateways' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Marker": "",
  "Limit": ""
}'

echo '{
  "Marker": "",
  "Limit": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Marker": "",\n  "Limit": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Marker": "",
  "Limit": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListGateways")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "Gateways": [
    {
      "GatewayARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B"
    },
    {
      "GatewayARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-23A4567C"
    }
  ],
  "Marker": "1"
}

POST ListLocalDisks

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks" {:headers {:x-amz-target ""}
                                                                                                 :content-type :json
                                                                                                 :form-params {:GatewayARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "GatewayARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\"\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  \"GatewayARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks",
  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([
    'GatewayARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks', [
  'body' => '{
  "GatewayARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks"

payload = { "GatewayARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks"

payload <- "{\n  \"GatewayARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks";

    let payload = json!({"GatewayARN": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": ""
}'

echo '{
  "GatewayARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["GatewayARN": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListLocalDisks")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "Disks": [
    {
      "DiskAllocationType": "CACHE_STORAGE",
      "DiskId": "pci-0000:03:00.0-scsi-0:0:0:0",
      "DiskNode": "SCSI(0:0)",
      "DiskPath": "/dev/sda",
      "DiskSizeInBytes": 1099511627776,
      "DiskStatus": "missing"
    },
    {
      "DiskAllocationResource": "",
      "DiskAllocationType": "UPLOAD_BUFFER",
      "DiskId": "pci-0000:03:00.0-scsi-0:0:1:0",
      "DiskNode": "SCSI(0:1)",
      "DiskPath": "/dev/sdb",
      "DiskSizeInBytes": 1099511627776,
      "DiskStatus": "present"
    }
  ],
  "GatewayARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B"
}

POST ListTagsForResource

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource

HEADERS

X-Amz-Target

BODY json

{
  "ResourceARN": "",
  "Marker": "",
  "Limit": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ResourceARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:ResourceARN ""
                                                                                                                    :Marker ""
                                                                                                                    :Limit ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ResourceARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ResourceARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ResourceARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource"

	payload := strings.NewReader("{\n  \"ResourceARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 54

{
  "ResourceARN": "",
  "Marker": "",
  "Limit": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ResourceARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ResourceARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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  \"ResourceARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ResourceARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ResourceARN: '',
  Marker: '',
  Limit: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceARN: '', Marker: '', Limit: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceARN":"","Marker":"","Limit":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResourceARN": "",\n  "Marker": "",\n  "Limit": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ResourceARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({ResourceARN: '', Marker: '', Limit: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ResourceARN: '', Marker: '', Limit: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ResourceARN: '',
  Marker: '',
  Limit: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceARN: '', Marker: '', Limit: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceARN":"","Marker":"","Limit":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ResourceARN": @"",
                              @"Marker": @"",
                              @"Limit": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ResourceARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource",
  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([
    'ResourceARN' => '',
    'Marker' => '',
    'Limit' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource', [
  'body' => '{
  "ResourceARN": "",
  "Marker": "",
  "Limit": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ResourceARN' => '',
  'Marker' => '',
  'Limit' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ResourceARN' => '',
  'Marker' => '',
  'Limit' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceARN": "",
  "Marker": "",
  "Limit": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceARN": "",
  "Marker": "",
  "Limit": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ResourceARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource"

payload = {
    "ResourceARN": "",
    "Marker": "",
    "Limit": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource"

payload <- "{\n  \"ResourceARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"ResourceARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"ResourceARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource";

    let payload = json!({
        "ResourceARN": "",
        "Marker": "",
        "Limit": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceARN": "",
  "Marker": "",
  "Limit": ""
}'

echo '{
  "ResourceARN": "",
  "Marker": "",
  "Limit": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ResourceARN": "",\n  "Marker": "",\n  "Limit": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ResourceARN": "",
  "Marker": "",
  "Limit": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTagsForResource")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "Marker": "1",
  "ResourceARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-11A2222B",
  "Tags": [
    {
      "Key": "Dev Gatgeway Region",
      "Value": "East Coast"
    }
  ]
}

POST ListTapePools

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools

HEADERS

X-Amz-Target

BODY json

{
  "PoolARNs": "",
  "Marker": "",
  "Limit": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"PoolARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools" {:headers {:x-amz-target ""}
                                                                                                :content-type :json
                                                                                                :form-params {:PoolARNs ""
                                                                                                              :Marker ""
                                                                                                              :Limit ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"PoolARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"PoolARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"PoolARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools"

	payload := strings.NewReader("{\n  \"PoolARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 51

{
  "PoolARNs": "",
  "Marker": "",
  "Limit": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"PoolARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"PoolARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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  \"PoolARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"PoolARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  PoolARNs: '',
  Marker: '',
  Limit: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {PoolARNs: '', Marker: '', Limit: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"PoolARNs":"","Marker":"","Limit":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "PoolARNs": "",\n  "Marker": "",\n  "Limit": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"PoolARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({PoolARNs: '', Marker: '', Limit: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {PoolARNs: '', Marker: '', Limit: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  PoolARNs: '',
  Marker: '',
  Limit: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {PoolARNs: '', Marker: '', Limit: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"PoolARNs":"","Marker":"","Limit":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"PoolARNs": @"",
                              @"Marker": @"",
                              @"Limit": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"PoolARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools",
  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([
    'PoolARNs' => '',
    'Marker' => '',
    'Limit' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools', [
  'body' => '{
  "PoolARNs": "",
  "Marker": "",
  "Limit": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'PoolARNs' => '',
  'Marker' => '',
  'Limit' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'PoolARNs' => '',
  'Marker' => '',
  'Limit' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PoolARNs": "",
  "Marker": "",
  "Limit": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "PoolARNs": "",
  "Marker": "",
  "Limit": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"PoolARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools"

payload = {
    "PoolARNs": "",
    "Marker": "",
    "Limit": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools"

payload <- "{\n  \"PoolARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"PoolARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"PoolARNs\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools";

    let payload = json!({
        "PoolARNs": "",
        "Marker": "",
        "Limit": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "PoolARNs": "",
  "Marker": "",
  "Limit": ""
}'

echo '{
  "PoolARNs": "",
  "Marker": "",
  "Limit": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "PoolARNs": "",\n  "Marker": "",\n  "Limit": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "PoolARNs": "",
  "Marker": "",
  "Limit": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapePools")! 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 ListTapes

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes

HEADERS

X-Amz-Target

BODY json

{
  "TapeARNs": [],
  "Marker": "",
  "Limit": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"TapeARNs\": [],\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes" {:headers {:x-amz-target ""}
                                                                                            :content-type :json
                                                                                            :form-params {:TapeARNs []
                                                                                                          :Marker ""
                                                                                                          :Limit ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TapeARNs\": [],\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.ListTapes"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TapeARNs\": [],\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.ListTapes");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TapeARNs\": [],\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes"

	payload := strings.NewReader("{\n  \"TapeARNs\": [],\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 51

{
  "TapeARNs": [],
  "Marker": "",
  "Limit": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TapeARNs\": [],\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TapeARNs\": [],\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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  \"TapeARNs\": [],\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TapeARNs\": [],\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TapeARNs: [],
  Marker: '',
  Limit: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TapeARNs: [], Marker: '', Limit: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TapeARNs":[],"Marker":"","Limit":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.ListTapes',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TapeARNs": [],\n  "Marker": "",\n  "Limit": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TapeARNs\": [],\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({TapeARNs: [], Marker: '', Limit: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {TapeARNs: [], Marker: '', Limit: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.ListTapes');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TapeARNs: [],
  Marker: '',
  Limit: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.ListTapes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TapeARNs: [], Marker: '', Limit: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TapeARNs":[],"Marker":"","Limit":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"TapeARNs": @[  ],
                              @"Marker": @"",
                              @"Limit": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.ListTapes" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TapeARNs\": [],\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes",
  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([
    'TapeARNs' => [
        
    ],
    'Marker' => '',
    'Limit' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes', [
  'body' => '{
  "TapeARNs": [],
  "Marker": "",
  "Limit": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TapeARNs' => [
    
  ],
  'Marker' => '',
  'Limit' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TapeARNs' => [
    
  ],
  'Marker' => '',
  'Limit' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TapeARNs": [],
  "Marker": "",
  "Limit": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TapeARNs": [],
  "Marker": "",
  "Limit": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TapeARNs\": [],\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes"

payload = {
    "TapeARNs": [],
    "Marker": "",
    "Limit": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes"

payload <- "{\n  \"TapeARNs\": [],\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"TapeARNs\": [],\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"TapeARNs\": [],\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes";

    let payload = json!({
        "TapeARNs": (),
        "Marker": "",
        "Limit": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.ListTapes' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "TapeARNs": [],
  "Marker": "",
  "Limit": ""
}'

echo '{
  "TapeARNs": [],
  "Marker": "",
  "Limit": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TapeARNs": [],\n  "Marker": "",\n  "Limit": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TapeARNs": [],
  "Marker": "",
  "Limit": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListTapes")! 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 ListVolumeInitiators

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators

HEADERS

X-Amz-Target

BODY json

{
  "VolumeARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"VolumeARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:VolumeARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"VolumeARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"VolumeARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"VolumeARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators"

	payload := strings.NewReader("{\n  \"VolumeARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 21

{
  "VolumeARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"VolumeARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"VolumeARN\": \"\"\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  \"VolumeARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"VolumeARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  VolumeARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {VolumeARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"VolumeARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "VolumeARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"VolumeARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({VolumeARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {VolumeARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  VolumeARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {VolumeARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"VolumeARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"VolumeARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"VolumeARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators",
  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([
    'VolumeARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators', [
  'body' => '{
  "VolumeARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'VolumeARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'VolumeARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "VolumeARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "VolumeARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"VolumeARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators"

payload = { "VolumeARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators"

payload <- "{\n  \"VolumeARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"VolumeARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"VolumeARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators";

    let payload = json!({"VolumeARN": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "VolumeARN": ""
}'

echo '{
  "VolumeARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "VolumeARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["VolumeARN": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeInitiators")! 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 ListVolumeRecoveryPoints

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:GatewayARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "GatewayARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\"\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  \"GatewayARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints",
  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([
    'GatewayARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints', [
  'body' => '{
  "GatewayARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints"

payload = { "GatewayARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints"

payload <- "{\n  \"GatewayARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints";

    let payload = json!({"GatewayARN": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": ""
}'

echo '{
  "GatewayARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["GatewayARN": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumeRecoveryPoints")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "GatewayARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B",
  "VolumeRecoveryPointInfos": [
    {
      "VolumeARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B/volume/vol-1122AABB",
      "VolumeRecoveryPointTime": "2012-09-04T21:08:44.627Z",
      "VolumeSizeInBytes": 536870912000
    }
  ]
}

POST ListVolumes

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "Marker": "",
  "Limit": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes" {:headers {:x-amz-target ""}
                                                                                              :content-type :json
                                                                                              :form-params {:GatewayARN ""
                                                                                                            :Marker ""
                                                                                                            :Limit ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 53

{
  "GatewayARN": "",
  "Marker": "",
  "Limit": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  Marker: '',
  Limit: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', Marker: '', Limit: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","Marker":"","Limit":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "Marker": "",\n  "Limit": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: '', Marker: '', Limit: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: '', Marker: '', Limit: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: '',
  Marker: '',
  Limit: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', Marker: '', Limit: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","Marker":"","Limit":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"Marker": @"",
                              @"Limit": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes",
  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([
    'GatewayARN' => '',
    'Marker' => '',
    'Limit' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes', [
  'body' => '{
  "GatewayARN": "",
  "Marker": "",
  "Limit": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => '',
  'Marker' => '',
  'Limit' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => '',
  'Marker' => '',
  'Limit' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "Marker": "",
  "Limit": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "Marker": "",
  "Limit": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes"

payload = {
    "GatewayARN": "",
    "Marker": "",
    "Limit": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"Marker\": \"\",\n  \"Limit\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes";

    let payload = json!({
        "GatewayARN": "",
        "Marker": "",
        "Limit": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "Marker": "",
  "Limit": ""
}'

echo '{
  "GatewayARN": "",
  "Marker": "",
  "Limit": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "Marker": "",\n  "Limit": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "Marker": "",
  "Limit": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ListVolumes")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "GatewayARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B",
  "Marker": "1",
  "VolumeInfos": [
    {
      "GatewayARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B",
      "GatewayId": "sgw-12A3456B",
      "VolumeARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B/volume/vol-1122AABB",
      "VolumeId": "vol-1122AABB",
      "VolumeSizeInBytes": 107374182400,
      "VolumeType": "STORED"
    },
    {
      "GatewayARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-13B4567C",
      "GatewayId": "sgw-gw-13B4567C",
      "VolumeARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-13B4567C/volume/vol-3344CCDD",
      "VolumeId": "vol-1122AABB",
      "VolumeSizeInBytes": 107374182400,
      "VolumeType": "STORED"
    }
  ]
}

POST NotifyWhenUploaded

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded

HEADERS

X-Amz-Target

BODY json

{
  "FileShareARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"FileShareARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:FileShareARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"FileShareARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"FileShareARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"FileShareARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded"

	payload := strings.NewReader("{\n  \"FileShareARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 24

{
  "FileShareARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"FileShareARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"FileShareARN\": \"\"\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  \"FileShareARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"FileShareARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  FileShareARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {FileShareARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FileShareARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "FileShareARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"FileShareARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({FileShareARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {FileShareARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  FileShareARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {FileShareARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FileShareARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"FileShareARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"FileShareARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded",
  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([
    'FileShareARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded', [
  'body' => '{
  "FileShareARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'FileShareARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'FileShareARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FileShareARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FileShareARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"FileShareARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded"

payload = { "FileShareARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded"

payload <- "{\n  \"FileShareARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"FileShareARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"FileShareARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded";

    let payload = json!({"FileShareARN": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "FileShareARN": ""
}'

echo '{
  "FileShareARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "FileShareARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["FileShareARN": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.NotifyWhenUploaded")! 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 RefreshCache

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache

HEADERS

X-Amz-Target

BODY json

{
  "FileShareARN": "",
  "FolderList": "",
  "Recursive": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"FileShareARN\": \"\",\n  \"FolderList\": \"\",\n  \"Recursive\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache" {:headers {:x-amz-target ""}
                                                                                               :content-type :json
                                                                                               :form-params {:FileShareARN ""
                                                                                                             :FolderList ""
                                                                                                             :Recursive ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"FileShareARN\": \"\",\n  \"FolderList\": \"\",\n  \"Recursive\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"FileShareARN\": \"\",\n  \"FolderList\": \"\",\n  \"Recursive\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"FileShareARN\": \"\",\n  \"FolderList\": \"\",\n  \"Recursive\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache"

	payload := strings.NewReader("{\n  \"FileShareARN\": \"\",\n  \"FolderList\": \"\",\n  \"Recursive\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 63

{
  "FileShareARN": "",
  "FolderList": "",
  "Recursive": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"FileShareARN\": \"\",\n  \"FolderList\": \"\",\n  \"Recursive\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"FileShareARN\": \"\",\n  \"FolderList\": \"\",\n  \"Recursive\": \"\"\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  \"FileShareARN\": \"\",\n  \"FolderList\": \"\",\n  \"Recursive\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"FileShareARN\": \"\",\n  \"FolderList\": \"\",\n  \"Recursive\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  FileShareARN: '',
  FolderList: '',
  Recursive: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {FileShareARN: '', FolderList: '', Recursive: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FileShareARN":"","FolderList":"","Recursive":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "FileShareARN": "",\n  "FolderList": "",\n  "Recursive": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"FileShareARN\": \"\",\n  \"FolderList\": \"\",\n  \"Recursive\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({FileShareARN: '', FolderList: '', Recursive: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {FileShareARN: '', FolderList: '', Recursive: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  FileShareARN: '',
  FolderList: '',
  Recursive: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {FileShareARN: '', FolderList: '', Recursive: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FileShareARN":"","FolderList":"","Recursive":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"FileShareARN": @"",
                              @"FolderList": @"",
                              @"Recursive": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"FileShareARN\": \"\",\n  \"FolderList\": \"\",\n  \"Recursive\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache",
  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([
    'FileShareARN' => '',
    'FolderList' => '',
    'Recursive' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache', [
  'body' => '{
  "FileShareARN": "",
  "FolderList": "",
  "Recursive": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'FileShareARN' => '',
  'FolderList' => '',
  'Recursive' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'FileShareARN' => '',
  'FolderList' => '',
  'Recursive' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FileShareARN": "",
  "FolderList": "",
  "Recursive": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FileShareARN": "",
  "FolderList": "",
  "Recursive": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"FileShareARN\": \"\",\n  \"FolderList\": \"\",\n  \"Recursive\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache"

payload = {
    "FileShareARN": "",
    "FolderList": "",
    "Recursive": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache"

payload <- "{\n  \"FileShareARN\": \"\",\n  \"FolderList\": \"\",\n  \"Recursive\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"FileShareARN\": \"\",\n  \"FolderList\": \"\",\n  \"Recursive\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"FileShareARN\": \"\",\n  \"FolderList\": \"\",\n  \"Recursive\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache";

    let payload = json!({
        "FileShareARN": "",
        "FolderList": "",
        "Recursive": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "FileShareARN": "",
  "FolderList": "",
  "Recursive": ""
}'

echo '{
  "FileShareARN": "",
  "FolderList": "",
  "Recursive": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "FileShareARN": "",\n  "FolderList": "",\n  "Recursive": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "FileShareARN": "",
  "FolderList": "",
  "Recursive": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RefreshCache")! 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 RemoveTagsFromResource

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource

HEADERS

X-Amz-Target

BODY json

{
  "ResourceARN": "",
  "TagKeys": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"ResourceARN\": \"\",\n  \"TagKeys\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:ResourceARN ""
                                                                                                                       :TagKeys ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ResourceARN\": \"\",\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}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ResourceARN\": \"\",\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}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ResourceARN\": \"\",\n  \"TagKeys\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource"

	payload := strings.NewReader("{\n  \"ResourceARN\": \"\",\n  \"TagKeys\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "ResourceARN": "",
  "TagKeys": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ResourceARN\": \"\",\n  \"TagKeys\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ResourceARN\": \"\",\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  \"ResourceARN\": \"\",\n  \"TagKeys\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ResourceARN\": \"\",\n  \"TagKeys\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ResourceARN: '',
  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}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceARN: '', TagKeys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceARN":"","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}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResourceARN": "",\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  \"ResourceARN\": \"\",\n  \"TagKeys\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({ResourceARN: '', TagKeys: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ResourceARN: '', 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}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ResourceARN: '',
  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}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceARN: '', TagKeys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceARN":"","TagKeys":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"ResourceARN": @"",
                              @"TagKeys": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ResourceARN\": \"\",\n  \"TagKeys\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource",
  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([
    'ResourceARN' => '',
    'TagKeys' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource', [
  'body' => '{
  "ResourceARN": "",
  "TagKeys": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ResourceARN' => '',
  'TagKeys' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ResourceARN' => '',
  'TagKeys' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceARN": "",
  "TagKeys": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceARN": "",
  "TagKeys": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ResourceARN\": \"\",\n  \"TagKeys\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource"

payload = {
    "ResourceARN": "",
    "TagKeys": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource"

payload <- "{\n  \"ResourceARN\": \"\",\n  \"TagKeys\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"ResourceARN\": \"\",\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"ResourceARN\": \"\",\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}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource";

    let payload = json!({
        "ResourceARN": "",
        "TagKeys": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceARN": "",
  "TagKeys": ""
}'

echo '{
  "ResourceARN": "",
  "TagKeys": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ResourceARN": "",\n  "TagKeys": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ResourceARN": "",
  "TagKeys": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RemoveTagsFromResource")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "ResourceARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-11A2222B"
}

POST ResetCache

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache" {:headers {:x-amz-target ""}
                                                                                             :content-type :json
                                                                                             :form-params {:GatewayARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.ResetCache"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.ResetCache");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "GatewayARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\"\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  \"GatewayARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.ResetCache',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.ResetCache');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.ResetCache',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.ResetCache" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache",
  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([
    'GatewayARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache', [
  'body' => '{
  "GatewayARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache"

payload = { "GatewayARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache"

payload <- "{\n  \"GatewayARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache";

    let payload = json!({"GatewayARN": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.ResetCache' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": ""
}'

echo '{
  "GatewayARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["GatewayARN": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ResetCache")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "GatewayARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-13B4567C"
}

POST RetrieveTapeArchive

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive

HEADERS

X-Amz-Target

BODY json

{
  "TapeARN": "",
  "GatewayARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:TapeARN ""
                                                                                                                    :GatewayARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive"

	payload := strings.NewReader("{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 39

{
  "TapeARN": "",
  "GatewayARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\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  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TapeARN: '',
  GatewayARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TapeARN: '', GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TapeARN":"","GatewayARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TapeARN": "",\n  "GatewayARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({TapeARN: '', GatewayARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {TapeARN: '', GatewayARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TapeARN: '',
  GatewayARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TapeARN: '', GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TapeARN":"","GatewayARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"TapeARN": @"",
                              @"GatewayARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive",
  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([
    'TapeARN' => '',
    'GatewayARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive', [
  'body' => '{
  "TapeARN": "",
  "GatewayARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TapeARN' => '',
  'GatewayARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TapeARN' => '',
  'GatewayARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TapeARN": "",
  "GatewayARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TapeARN": "",
  "GatewayARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive"

payload = {
    "TapeARN": "",
    "GatewayARN": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive"

payload <- "{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive";

    let payload = json!({
        "TapeARN": "",
        "GatewayARN": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "TapeARN": "",
  "GatewayARN": ""
}'

echo '{
  "TapeARN": "",
  "GatewayARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TapeARN": "",\n  "GatewayARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TapeARN": "",
  "GatewayARN": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeArchive")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "TapeARN": "arn:aws:storagegateway:us-east-1:999999999999:tape/TEST0AA2AF"
}

POST RetrieveTapeRecoveryPoint

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint

HEADERS

X-Amz-Target

BODY json

{
  "TapeARN": "",
  "GatewayARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:TapeARN ""
                                                                                                                          :GatewayARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint"

	payload := strings.NewReader("{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 39

{
  "TapeARN": "",
  "GatewayARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\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  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TapeARN: '',
  GatewayARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TapeARN: '', GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TapeARN":"","GatewayARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TapeARN": "",\n  "GatewayARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({TapeARN: '', GatewayARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {TapeARN: '', GatewayARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TapeARN: '',
  GatewayARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TapeARN: '', GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TapeARN":"","GatewayARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"TapeARN": @"",
                              @"GatewayARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint",
  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([
    'TapeARN' => '',
    'GatewayARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint', [
  'body' => '{
  "TapeARN": "",
  "GatewayARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TapeARN' => '',
  'GatewayARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TapeARN' => '',
  'GatewayARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TapeARN": "",
  "GatewayARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TapeARN": "",
  "GatewayARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint"

payload = {
    "TapeARN": "",
    "GatewayARN": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint"

payload <- "{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"TapeARN\": \"\",\n  \"GatewayARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint";

    let payload = json!({
        "TapeARN": "",
        "GatewayARN": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "TapeARN": "",
  "GatewayARN": ""
}'

echo '{
  "TapeARN": "",
  "GatewayARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TapeARN": "",\n  "GatewayARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TapeARN": "",
  "GatewayARN": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.RetrieveTapeRecoveryPoint")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "TapeARN": "arn:aws:storagegateway:us-east-1:999999999999:tape/TEST0AA2AF"
}

POST SetLocalConsolePassword

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "LocalConsolePassword": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\",\n  \"LocalConsolePassword\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:GatewayARN ""
                                                                                                                        :LocalConsolePassword ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"LocalConsolePassword\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"LocalConsolePassword\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"LocalConsolePassword\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"LocalConsolePassword\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 52

{
  "GatewayARN": "",
  "LocalConsolePassword": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"LocalConsolePassword\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"LocalConsolePassword\": \"\"\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  \"GatewayARN\": \"\",\n  \"LocalConsolePassword\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"LocalConsolePassword\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  LocalConsolePassword: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', LocalConsolePassword: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","LocalConsolePassword":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "LocalConsolePassword": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"LocalConsolePassword\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: '', LocalConsolePassword: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: '', LocalConsolePassword: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: '',
  LocalConsolePassword: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', LocalConsolePassword: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","LocalConsolePassword":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"LocalConsolePassword": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"LocalConsolePassword\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword",
  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([
    'GatewayARN' => '',
    'LocalConsolePassword' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword', [
  'body' => '{
  "GatewayARN": "",
  "LocalConsolePassword": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => '',
  'LocalConsolePassword' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => '',
  'LocalConsolePassword' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "LocalConsolePassword": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "LocalConsolePassword": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\",\n  \"LocalConsolePassword\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword"

payload = {
    "GatewayARN": "",
    "LocalConsolePassword": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"LocalConsolePassword\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"LocalConsolePassword\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"LocalConsolePassword\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword";

    let payload = json!({
        "GatewayARN": "",
        "LocalConsolePassword": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "LocalConsolePassword": ""
}'

echo '{
  "GatewayARN": "",
  "LocalConsolePassword": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "LocalConsolePassword": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "LocalConsolePassword": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetLocalConsolePassword")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "GatewayARN": "arn:aws:storagegateway:us-east-1:999999999999:gateway/sgw-12A3456B"
}

POST SetSMBGuestPassword

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "Password": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\",\n  \"Password\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:GatewayARN ""
                                                                                                                    :Password ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"Password\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"Password\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"Password\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"Password\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "GatewayARN": "",
  "Password": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"Password\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"Password\": \"\"\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  \"GatewayARN\": \"\",\n  \"Password\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"Password\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  Password: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', Password: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","Password":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "Password": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"Password\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: '', Password: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: '', Password: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: '',
  Password: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', Password: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","Password":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"Password": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"Password\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword",
  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([
    'GatewayARN' => '',
    'Password' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword', [
  'body' => '{
  "GatewayARN": "",
  "Password": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => '',
  'Password' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => '',
  'Password' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "Password": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "Password": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\",\n  \"Password\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword"

payload = {
    "GatewayARN": "",
    "Password": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"Password\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"Password\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"Password\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword";

    let payload = json!({
        "GatewayARN": "",
        "Password": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "Password": ""
}'

echo '{
  "GatewayARN": "",
  "Password": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "Password": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "Password": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.SetSMBGuestPassword")! 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 ShutdownGateway

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:GatewayARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "GatewayARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\"\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  \"GatewayARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway",
  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([
    'GatewayARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway', [
  'body' => '{
  "GatewayARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway"

payload = { "GatewayARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway"

payload <- "{\n  \"GatewayARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway";

    let payload = json!({"GatewayARN": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": ""
}'

echo '{
  "GatewayARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["GatewayARN": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.ShutdownGateway")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "GatewayARN": "arn:aws:storagegateway:us-east-1:999999999999:gateway/sgw-12A3456B"
}

POST StartAvailabilityMonitorTest

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:GatewayARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "GatewayARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\"\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  \"GatewayARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest",
  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([
    'GatewayARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest', [
  'body' => '{
  "GatewayARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest"

payload = { "GatewayARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest"

payload <- "{\n  \"GatewayARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest";

    let payload = json!({"GatewayARN": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": ""
}'

echo '{
  "GatewayARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["GatewayARN": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartAvailabilityMonitorTest")! 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 StartGateway

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway" {:headers {:x-amz-target ""}
                                                                                               :content-type :json
                                                                                               :form-params {:GatewayARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.StartGateway"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.StartGateway");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "GatewayARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\"\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  \"GatewayARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.StartGateway',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.StartGateway');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.StartGateway',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.StartGateway" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway",
  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([
    'GatewayARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway', [
  'body' => '{
  "GatewayARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway"

payload = { "GatewayARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway"

payload <- "{\n  \"GatewayARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway";

    let payload = json!({"GatewayARN": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.StartGateway' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": ""
}'

echo '{
  "GatewayARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["GatewayARN": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.StartGateway")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "GatewayARN": "arn:aws:storagegateway:us-east-1:999999999999:gateway/sgw-12A3456B"
}

POST UpdateAutomaticTapeCreationPolicy

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy

HEADERS

X-Amz-Target

BODY json

{
  "AutomaticTapeCreationRules": "",
  "GatewayARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"AutomaticTapeCreationRules\": \"\",\n  \"GatewayARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy" {:headers {:x-amz-target ""}
                                                                                                                    :content-type :json
                                                                                                                    :form-params {:AutomaticTapeCreationRules ""
                                                                                                                                  :GatewayARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AutomaticTapeCreationRules\": \"\",\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AutomaticTapeCreationRules\": \"\",\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AutomaticTapeCreationRules\": \"\",\n  \"GatewayARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy"

	payload := strings.NewReader("{\n  \"AutomaticTapeCreationRules\": \"\",\n  \"GatewayARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 58

{
  "AutomaticTapeCreationRules": "",
  "GatewayARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AutomaticTapeCreationRules\": \"\",\n  \"GatewayARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AutomaticTapeCreationRules\": \"\",\n  \"GatewayARN\": \"\"\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  \"AutomaticTapeCreationRules\": \"\",\n  \"GatewayARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AutomaticTapeCreationRules\": \"\",\n  \"GatewayARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AutomaticTapeCreationRules: '',
  GatewayARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AutomaticTapeCreationRules: '', GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AutomaticTapeCreationRules":"","GatewayARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AutomaticTapeCreationRules": "",\n  "GatewayARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AutomaticTapeCreationRules\": \"\",\n  \"GatewayARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({AutomaticTapeCreationRules: '', GatewayARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {AutomaticTapeCreationRules: '', GatewayARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  AutomaticTapeCreationRules: '',
  GatewayARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AutomaticTapeCreationRules: '', GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AutomaticTapeCreationRules":"","GatewayARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"AutomaticTapeCreationRules": @"",
                              @"GatewayARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AutomaticTapeCreationRules\": \"\",\n  \"GatewayARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy",
  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([
    'AutomaticTapeCreationRules' => '',
    'GatewayARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy', [
  'body' => '{
  "AutomaticTapeCreationRules": "",
  "GatewayARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AutomaticTapeCreationRules' => '',
  'GatewayARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'AutomaticTapeCreationRules' => '',
  'GatewayARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AutomaticTapeCreationRules": "",
  "GatewayARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AutomaticTapeCreationRules": "",
  "GatewayARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"AutomaticTapeCreationRules\": \"\",\n  \"GatewayARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy"

payload = {
    "AutomaticTapeCreationRules": "",
    "GatewayARN": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy"

payload <- "{\n  \"AutomaticTapeCreationRules\": \"\",\n  \"GatewayARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"AutomaticTapeCreationRules\": \"\",\n  \"GatewayARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"AutomaticTapeCreationRules\": \"\",\n  \"GatewayARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy";

    let payload = json!({
        "AutomaticTapeCreationRules": "",
        "GatewayARN": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AutomaticTapeCreationRules": "",
  "GatewayARN": ""
}'

echo '{
  "AutomaticTapeCreationRules": "",
  "GatewayARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AutomaticTapeCreationRules": "",\n  "GatewayARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AutomaticTapeCreationRules": "",
  "GatewayARN": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy")! 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 UpdateBandwidthRateLimit

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "AverageUploadRateLimitInBitsPerSec": "",
  "AverageDownloadRateLimitInBitsPerSec": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\",\n  \"AverageUploadRateLimitInBitsPerSec\": \"\",\n  \"AverageDownloadRateLimitInBitsPerSec\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:GatewayARN ""
                                                                                                                         :AverageUploadRateLimitInBitsPerSec ""
                                                                                                                         :AverageDownloadRateLimitInBitsPerSec ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"AverageUploadRateLimitInBitsPerSec\": \"\",\n  \"AverageDownloadRateLimitInBitsPerSec\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"AverageUploadRateLimitInBitsPerSec\": \"\",\n  \"AverageDownloadRateLimitInBitsPerSec\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"AverageUploadRateLimitInBitsPerSec\": \"\",\n  \"AverageDownloadRateLimitInBitsPerSec\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"AverageUploadRateLimitInBitsPerSec\": \"\",\n  \"AverageDownloadRateLimitInBitsPerSec\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 112

{
  "GatewayARN": "",
  "AverageUploadRateLimitInBitsPerSec": "",
  "AverageDownloadRateLimitInBitsPerSec": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"AverageUploadRateLimitInBitsPerSec\": \"\",\n  \"AverageDownloadRateLimitInBitsPerSec\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"AverageUploadRateLimitInBitsPerSec\": \"\",\n  \"AverageDownloadRateLimitInBitsPerSec\": \"\"\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  \"GatewayARN\": \"\",\n  \"AverageUploadRateLimitInBitsPerSec\": \"\",\n  \"AverageDownloadRateLimitInBitsPerSec\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"AverageUploadRateLimitInBitsPerSec\": \"\",\n  \"AverageDownloadRateLimitInBitsPerSec\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  AverageUploadRateLimitInBitsPerSec: '',
  AverageDownloadRateLimitInBitsPerSec: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    GatewayARN: '',
    AverageUploadRateLimitInBitsPerSec: '',
    AverageDownloadRateLimitInBitsPerSec: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","AverageUploadRateLimitInBitsPerSec":"","AverageDownloadRateLimitInBitsPerSec":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "AverageUploadRateLimitInBitsPerSec": "",\n  "AverageDownloadRateLimitInBitsPerSec": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"AverageUploadRateLimitInBitsPerSec\": \"\",\n  \"AverageDownloadRateLimitInBitsPerSec\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({
  GatewayARN: '',
  AverageUploadRateLimitInBitsPerSec: '',
  AverageDownloadRateLimitInBitsPerSec: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    GatewayARN: '',
    AverageUploadRateLimitInBitsPerSec: '',
    AverageDownloadRateLimitInBitsPerSec: ''
  },
  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}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: '',
  AverageUploadRateLimitInBitsPerSec: '',
  AverageDownloadRateLimitInBitsPerSec: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    GatewayARN: '',
    AverageUploadRateLimitInBitsPerSec: '',
    AverageDownloadRateLimitInBitsPerSec: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","AverageUploadRateLimitInBitsPerSec":"","AverageDownloadRateLimitInBitsPerSec":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"AverageUploadRateLimitInBitsPerSec": @"",
                              @"AverageDownloadRateLimitInBitsPerSec": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"AverageUploadRateLimitInBitsPerSec\": \"\",\n  \"AverageDownloadRateLimitInBitsPerSec\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit",
  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([
    'GatewayARN' => '',
    'AverageUploadRateLimitInBitsPerSec' => '',
    'AverageDownloadRateLimitInBitsPerSec' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit', [
  'body' => '{
  "GatewayARN": "",
  "AverageUploadRateLimitInBitsPerSec": "",
  "AverageDownloadRateLimitInBitsPerSec": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => '',
  'AverageUploadRateLimitInBitsPerSec' => '',
  'AverageDownloadRateLimitInBitsPerSec' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => '',
  'AverageUploadRateLimitInBitsPerSec' => '',
  'AverageDownloadRateLimitInBitsPerSec' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "AverageUploadRateLimitInBitsPerSec": "",
  "AverageDownloadRateLimitInBitsPerSec": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "AverageUploadRateLimitInBitsPerSec": "",
  "AverageDownloadRateLimitInBitsPerSec": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\",\n  \"AverageUploadRateLimitInBitsPerSec\": \"\",\n  \"AverageDownloadRateLimitInBitsPerSec\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit"

payload = {
    "GatewayARN": "",
    "AverageUploadRateLimitInBitsPerSec": "",
    "AverageDownloadRateLimitInBitsPerSec": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"AverageUploadRateLimitInBitsPerSec\": \"\",\n  \"AverageDownloadRateLimitInBitsPerSec\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"AverageUploadRateLimitInBitsPerSec\": \"\",\n  \"AverageDownloadRateLimitInBitsPerSec\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"AverageUploadRateLimitInBitsPerSec\": \"\",\n  \"AverageDownloadRateLimitInBitsPerSec\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit";

    let payload = json!({
        "GatewayARN": "",
        "AverageUploadRateLimitInBitsPerSec": "",
        "AverageDownloadRateLimitInBitsPerSec": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "AverageUploadRateLimitInBitsPerSec": "",
  "AverageDownloadRateLimitInBitsPerSec": ""
}'

echo '{
  "GatewayARN": "",
  "AverageUploadRateLimitInBitsPerSec": "",
  "AverageDownloadRateLimitInBitsPerSec": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "AverageUploadRateLimitInBitsPerSec": "",\n  "AverageDownloadRateLimitInBitsPerSec": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "AverageUploadRateLimitInBitsPerSec": "",
  "AverageDownloadRateLimitInBitsPerSec": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimit")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "GatewayARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B"
}

POST UpdateBandwidthRateLimitSchedule

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "BandwidthRateLimitIntervals": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\",\n  \"BandwidthRateLimitIntervals\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:GatewayARN ""
                                                                                                                                 :BandwidthRateLimitIntervals ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"BandwidthRateLimitIntervals\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"BandwidthRateLimitIntervals\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"BandwidthRateLimitIntervals\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"BandwidthRateLimitIntervals\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 59

{
  "GatewayARN": "",
  "BandwidthRateLimitIntervals": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"BandwidthRateLimitIntervals\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"BandwidthRateLimitIntervals\": \"\"\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  \"GatewayARN\": \"\",\n  \"BandwidthRateLimitIntervals\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"BandwidthRateLimitIntervals\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  BandwidthRateLimitIntervals: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', BandwidthRateLimitIntervals: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","BandwidthRateLimitIntervals":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "BandwidthRateLimitIntervals": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"BandwidthRateLimitIntervals\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: '', BandwidthRateLimitIntervals: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: '', BandwidthRateLimitIntervals: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: '',
  BandwidthRateLimitIntervals: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', BandwidthRateLimitIntervals: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","BandwidthRateLimitIntervals":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"BandwidthRateLimitIntervals": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"BandwidthRateLimitIntervals\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule",
  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([
    'GatewayARN' => '',
    'BandwidthRateLimitIntervals' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule', [
  'body' => '{
  "GatewayARN": "",
  "BandwidthRateLimitIntervals": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => '',
  'BandwidthRateLimitIntervals' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => '',
  'BandwidthRateLimitIntervals' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "BandwidthRateLimitIntervals": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "BandwidthRateLimitIntervals": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\",\n  \"BandwidthRateLimitIntervals\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule"

payload = {
    "GatewayARN": "",
    "BandwidthRateLimitIntervals": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"BandwidthRateLimitIntervals\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"BandwidthRateLimitIntervals\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"BandwidthRateLimitIntervals\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule";

    let payload = json!({
        "GatewayARN": "",
        "BandwidthRateLimitIntervals": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "BandwidthRateLimitIntervals": ""
}'

echo '{
  "GatewayARN": "",
  "BandwidthRateLimitIntervals": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "BandwidthRateLimitIntervals": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "BandwidthRateLimitIntervals": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateBandwidthRateLimitSchedule")! 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 UpdateChapCredentials

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials

HEADERS

X-Amz-Target

BODY json

{
  "TargetARN": "",
  "SecretToAuthenticateInitiator": "",
  "InitiatorName": "",
  "SecretToAuthenticateTarget": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"TargetARN\": \"\",\n  \"SecretToAuthenticateInitiator\": \"\",\n  \"InitiatorName\": \"\",\n  \"SecretToAuthenticateTarget\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:TargetARN ""
                                                                                                                      :SecretToAuthenticateInitiator ""
                                                                                                                      :InitiatorName ""
                                                                                                                      :SecretToAuthenticateTarget ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TargetARN\": \"\",\n  \"SecretToAuthenticateInitiator\": \"\",\n  \"InitiatorName\": \"\",\n  \"SecretToAuthenticateTarget\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TargetARN\": \"\",\n  \"SecretToAuthenticateInitiator\": \"\",\n  \"InitiatorName\": \"\",\n  \"SecretToAuthenticateTarget\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TargetARN\": \"\",\n  \"SecretToAuthenticateInitiator\": \"\",\n  \"InitiatorName\": \"\",\n  \"SecretToAuthenticateTarget\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials"

	payload := strings.NewReader("{\n  \"TargetARN\": \"\",\n  \"SecretToAuthenticateInitiator\": \"\",\n  \"InitiatorName\": \"\",\n  \"SecretToAuthenticateTarget\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 119

{
  "TargetARN": "",
  "SecretToAuthenticateInitiator": "",
  "InitiatorName": "",
  "SecretToAuthenticateTarget": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TargetARN\": \"\",\n  \"SecretToAuthenticateInitiator\": \"\",\n  \"InitiatorName\": \"\",\n  \"SecretToAuthenticateTarget\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TargetARN\": \"\",\n  \"SecretToAuthenticateInitiator\": \"\",\n  \"InitiatorName\": \"\",\n  \"SecretToAuthenticateTarget\": \"\"\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  \"TargetARN\": \"\",\n  \"SecretToAuthenticateInitiator\": \"\",\n  \"InitiatorName\": \"\",\n  \"SecretToAuthenticateTarget\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TargetARN\": \"\",\n  \"SecretToAuthenticateInitiator\": \"\",\n  \"InitiatorName\": \"\",\n  \"SecretToAuthenticateTarget\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TargetARN: '',
  SecretToAuthenticateInitiator: '',
  InitiatorName: '',
  SecretToAuthenticateTarget: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TargetARN: '',
    SecretToAuthenticateInitiator: '',
    InitiatorName: '',
    SecretToAuthenticateTarget: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TargetARN":"","SecretToAuthenticateInitiator":"","InitiatorName":"","SecretToAuthenticateTarget":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TargetARN": "",\n  "SecretToAuthenticateInitiator": "",\n  "InitiatorName": "",\n  "SecretToAuthenticateTarget": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TargetARN\": \"\",\n  \"SecretToAuthenticateInitiator\": \"\",\n  \"InitiatorName\": \"\",\n  \"SecretToAuthenticateTarget\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({
  TargetARN: '',
  SecretToAuthenticateInitiator: '',
  InitiatorName: '',
  SecretToAuthenticateTarget: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    TargetARN: '',
    SecretToAuthenticateInitiator: '',
    InitiatorName: '',
    SecretToAuthenticateTarget: ''
  },
  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}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  TargetARN: '',
  SecretToAuthenticateInitiator: '',
  InitiatorName: '',
  SecretToAuthenticateTarget: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TargetARN: '',
    SecretToAuthenticateInitiator: '',
    InitiatorName: '',
    SecretToAuthenticateTarget: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TargetARN":"","SecretToAuthenticateInitiator":"","InitiatorName":"","SecretToAuthenticateTarget":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"TargetARN": @"",
                              @"SecretToAuthenticateInitiator": @"",
                              @"InitiatorName": @"",
                              @"SecretToAuthenticateTarget": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TargetARN\": \"\",\n  \"SecretToAuthenticateInitiator\": \"\",\n  \"InitiatorName\": \"\",\n  \"SecretToAuthenticateTarget\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials",
  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([
    'TargetARN' => '',
    'SecretToAuthenticateInitiator' => '',
    'InitiatorName' => '',
    'SecretToAuthenticateTarget' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials', [
  'body' => '{
  "TargetARN": "",
  "SecretToAuthenticateInitiator": "",
  "InitiatorName": "",
  "SecretToAuthenticateTarget": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TargetARN' => '',
  'SecretToAuthenticateInitiator' => '',
  'InitiatorName' => '',
  'SecretToAuthenticateTarget' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'TargetARN' => '',
  'SecretToAuthenticateInitiator' => '',
  'InitiatorName' => '',
  'SecretToAuthenticateTarget' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TargetARN": "",
  "SecretToAuthenticateInitiator": "",
  "InitiatorName": "",
  "SecretToAuthenticateTarget": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TargetARN": "",
  "SecretToAuthenticateInitiator": "",
  "InitiatorName": "",
  "SecretToAuthenticateTarget": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"TargetARN\": \"\",\n  \"SecretToAuthenticateInitiator\": \"\",\n  \"InitiatorName\": \"\",\n  \"SecretToAuthenticateTarget\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials"

payload = {
    "TargetARN": "",
    "SecretToAuthenticateInitiator": "",
    "InitiatorName": "",
    "SecretToAuthenticateTarget": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials"

payload <- "{\n  \"TargetARN\": \"\",\n  \"SecretToAuthenticateInitiator\": \"\",\n  \"InitiatorName\": \"\",\n  \"SecretToAuthenticateTarget\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"TargetARN\": \"\",\n  \"SecretToAuthenticateInitiator\": \"\",\n  \"InitiatorName\": \"\",\n  \"SecretToAuthenticateTarget\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"TargetARN\": \"\",\n  \"SecretToAuthenticateInitiator\": \"\",\n  \"InitiatorName\": \"\",\n  \"SecretToAuthenticateTarget\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials";

    let payload = json!({
        "TargetARN": "",
        "SecretToAuthenticateInitiator": "",
        "InitiatorName": "",
        "SecretToAuthenticateTarget": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "TargetARN": "",
  "SecretToAuthenticateInitiator": "",
  "InitiatorName": "",
  "SecretToAuthenticateTarget": ""
}'

echo '{
  "TargetARN": "",
  "SecretToAuthenticateInitiator": "",
  "InitiatorName": "",
  "SecretToAuthenticateTarget": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TargetARN": "",\n  "SecretToAuthenticateInitiator": "",\n  "InitiatorName": "",\n  "SecretToAuthenticateTarget": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TargetARN": "",
  "SecretToAuthenticateInitiator": "",
  "InitiatorName": "",
  "SecretToAuthenticateTarget": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateChapCredentials")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "InitiatorName": "iqn.1991-05.com.microsoft:computername.domain.example.com",
  "TargetARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B/target/iqn.1997-05.com.amazon:myvolume"
}

POST UpdateFileSystemAssociation

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation

HEADERS

X-Amz-Target

BODY json

{
  "FileSystemAssociationARN": "",
  "UserName": "",
  "Password": "",
  "AuditDestinationARN": "",
  "CacheAttributes": {
    "CacheStaleTimeoutInSeconds": ""
  }
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"FileSystemAssociationARN\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\n  }\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation" {:headers {:x-amz-target ""}
                                                                                                              :content-type :json
                                                                                                              :form-params {:FileSystemAssociationARN ""
                                                                                                                            :UserName ""
                                                                                                                            :Password ""
                                                                                                                            :AuditDestinationARN ""
                                                                                                                            :CacheAttributes {:CacheStaleTimeoutInSeconds ""}}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"FileSystemAssociationARN\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"FileSystemAssociationARN\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"FileSystemAssociationARN\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\n  }\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation"

	payload := strings.NewReader("{\n  \"FileSystemAssociationARN\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\n  }\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 166

{
  "FileSystemAssociationARN": "",
  "UserName": "",
  "Password": "",
  "AuditDestinationARN": "",
  "CacheAttributes": {
    "CacheStaleTimeoutInSeconds": ""
  }
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"FileSystemAssociationARN\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\n  }\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"FileSystemAssociationARN\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\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  \"FileSystemAssociationARN\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\n  }\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"FileSystemAssociationARN\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\n  }\n}")
  .asString();

const data = JSON.stringify({
  FileSystemAssociationARN: '',
  UserName: '',
  Password: '',
  AuditDestinationARN: '',
  CacheAttributes: {
    CacheStaleTimeoutInSeconds: ''
  }
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    FileSystemAssociationARN: '',
    UserName: '',
    Password: '',
    AuditDestinationARN: '',
    CacheAttributes: {CacheStaleTimeoutInSeconds: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FileSystemAssociationARN":"","UserName":"","Password":"","AuditDestinationARN":"","CacheAttributes":{"CacheStaleTimeoutInSeconds":""}}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "FileSystemAssociationARN": "",\n  "UserName": "",\n  "Password": "",\n  "AuditDestinationARN": "",\n  "CacheAttributes": {\n    "CacheStaleTimeoutInSeconds": ""\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  \"FileSystemAssociationARN\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\n  }\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({
  FileSystemAssociationARN: '',
  UserName: '',
  Password: '',
  AuditDestinationARN: '',
  CacheAttributes: {CacheStaleTimeoutInSeconds: ''}
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    FileSystemAssociationARN: '',
    UserName: '',
    Password: '',
    AuditDestinationARN: '',
    CacheAttributes: {CacheStaleTimeoutInSeconds: ''}
  },
  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}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  FileSystemAssociationARN: '',
  UserName: '',
  Password: '',
  AuditDestinationARN: '',
  CacheAttributes: {
    CacheStaleTimeoutInSeconds: ''
  }
});

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    FileSystemAssociationARN: '',
    UserName: '',
    Password: '',
    AuditDestinationARN: '',
    CacheAttributes: {CacheStaleTimeoutInSeconds: ''}
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FileSystemAssociationARN":"","UserName":"","Password":"","AuditDestinationARN":"","CacheAttributes":{"CacheStaleTimeoutInSeconds":""}}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"FileSystemAssociationARN": @"",
                              @"UserName": @"",
                              @"Password": @"",
                              @"AuditDestinationARN": @"",
                              @"CacheAttributes": @{ @"CacheStaleTimeoutInSeconds": @"" } };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"FileSystemAssociationARN\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\n  }\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation",
  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([
    'FileSystemAssociationARN' => '',
    'UserName' => '',
    'Password' => '',
    'AuditDestinationARN' => '',
    'CacheAttributes' => [
        'CacheStaleTimeoutInSeconds' => ''
    ]
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation', [
  'body' => '{
  "FileSystemAssociationARN": "",
  "UserName": "",
  "Password": "",
  "AuditDestinationARN": "",
  "CacheAttributes": {
    "CacheStaleTimeoutInSeconds": ""
  }
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'FileSystemAssociationARN' => '',
  'UserName' => '',
  'Password' => '',
  'AuditDestinationARN' => '',
  'CacheAttributes' => [
    'CacheStaleTimeoutInSeconds' => ''
  ]
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'FileSystemAssociationARN' => '',
  'UserName' => '',
  'Password' => '',
  'AuditDestinationARN' => '',
  'CacheAttributes' => [
    'CacheStaleTimeoutInSeconds' => ''
  ]
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FileSystemAssociationARN": "",
  "UserName": "",
  "Password": "",
  "AuditDestinationARN": "",
  "CacheAttributes": {
    "CacheStaleTimeoutInSeconds": ""
  }
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FileSystemAssociationARN": "",
  "UserName": "",
  "Password": "",
  "AuditDestinationARN": "",
  "CacheAttributes": {
    "CacheStaleTimeoutInSeconds": ""
  }
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"FileSystemAssociationARN\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\n  }\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation"

payload = {
    "FileSystemAssociationARN": "",
    "UserName": "",
    "Password": "",
    "AuditDestinationARN": "",
    "CacheAttributes": { "CacheStaleTimeoutInSeconds": "" }
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation"

payload <- "{\n  \"FileSystemAssociationARN\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\n  }\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"FileSystemAssociationARN\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"FileSystemAssociationARN\": \"\",\n  \"UserName\": \"\",\n  \"Password\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CacheAttributes\": {\n    \"CacheStaleTimeoutInSeconds\": \"\"\n  }\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation";

    let payload = json!({
        "FileSystemAssociationARN": "",
        "UserName": "",
        "Password": "",
        "AuditDestinationARN": "",
        "CacheAttributes": json!({"CacheStaleTimeoutInSeconds": ""})
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "FileSystemAssociationARN": "",
  "UserName": "",
  "Password": "",
  "AuditDestinationARN": "",
  "CacheAttributes": {
    "CacheStaleTimeoutInSeconds": ""
  }
}'

echo '{
  "FileSystemAssociationARN": "",
  "UserName": "",
  "Password": "",
  "AuditDestinationARN": "",
  "CacheAttributes": {
    "CacheStaleTimeoutInSeconds": ""
  }
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "FileSystemAssociationARN": "",\n  "UserName": "",\n  "Password": "",\n  "AuditDestinationARN": "",\n  "CacheAttributes": {\n    "CacheStaleTimeoutInSeconds": ""\n  }\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "FileSystemAssociationARN": "",
  "UserName": "",
  "Password": "",
  "AuditDestinationARN": "",
  "CacheAttributes": ["CacheStaleTimeoutInSeconds": ""]
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateFileSystemAssociation")! 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 UpdateGatewayInformation

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "GatewayName": "",
  "GatewayTimezone": "",
  "CloudWatchLogGroupARN": "",
  "GatewayCapacity": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"CloudWatchLogGroupARN\": \"\",\n  \"GatewayCapacity\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:GatewayARN ""
                                                                                                                         :GatewayName ""
                                                                                                                         :GatewayTimezone ""
                                                                                                                         :CloudWatchLogGroupARN ""
                                                                                                                         :GatewayCapacity ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"CloudWatchLogGroupARN\": \"\",\n  \"GatewayCapacity\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"CloudWatchLogGroupARN\": \"\",\n  \"GatewayCapacity\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"CloudWatchLogGroupARN\": \"\",\n  \"GatewayCapacity\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"CloudWatchLogGroupARN\": \"\",\n  \"GatewayCapacity\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 124

{
  "GatewayARN": "",
  "GatewayName": "",
  "GatewayTimezone": "",
  "CloudWatchLogGroupARN": "",
  "GatewayCapacity": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"CloudWatchLogGroupARN\": \"\",\n  \"GatewayCapacity\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"CloudWatchLogGroupARN\": \"\",\n  \"GatewayCapacity\": \"\"\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  \"GatewayARN\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"CloudWatchLogGroupARN\": \"\",\n  \"GatewayCapacity\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"CloudWatchLogGroupARN\": \"\",\n  \"GatewayCapacity\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  GatewayName: '',
  GatewayTimezone: '',
  CloudWatchLogGroupARN: '',
  GatewayCapacity: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    GatewayARN: '',
    GatewayName: '',
    GatewayTimezone: '',
    CloudWatchLogGroupARN: '',
    GatewayCapacity: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","GatewayName":"","GatewayTimezone":"","CloudWatchLogGroupARN":"","GatewayCapacity":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "GatewayName": "",\n  "GatewayTimezone": "",\n  "CloudWatchLogGroupARN": "",\n  "GatewayCapacity": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"CloudWatchLogGroupARN\": \"\",\n  \"GatewayCapacity\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({
  GatewayARN: '',
  GatewayName: '',
  GatewayTimezone: '',
  CloudWatchLogGroupARN: '',
  GatewayCapacity: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    GatewayARN: '',
    GatewayName: '',
    GatewayTimezone: '',
    CloudWatchLogGroupARN: '',
    GatewayCapacity: ''
  },
  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}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: '',
  GatewayName: '',
  GatewayTimezone: '',
  CloudWatchLogGroupARN: '',
  GatewayCapacity: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    GatewayARN: '',
    GatewayName: '',
    GatewayTimezone: '',
    CloudWatchLogGroupARN: '',
    GatewayCapacity: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","GatewayName":"","GatewayTimezone":"","CloudWatchLogGroupARN":"","GatewayCapacity":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"GatewayName": @"",
                              @"GatewayTimezone": @"",
                              @"CloudWatchLogGroupARN": @"",
                              @"GatewayCapacity": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"CloudWatchLogGroupARN\": \"\",\n  \"GatewayCapacity\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation",
  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([
    'GatewayARN' => '',
    'GatewayName' => '',
    'GatewayTimezone' => '',
    'CloudWatchLogGroupARN' => '',
    'GatewayCapacity' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation', [
  'body' => '{
  "GatewayARN": "",
  "GatewayName": "",
  "GatewayTimezone": "",
  "CloudWatchLogGroupARN": "",
  "GatewayCapacity": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => '',
  'GatewayName' => '',
  'GatewayTimezone' => '',
  'CloudWatchLogGroupARN' => '',
  'GatewayCapacity' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => '',
  'GatewayName' => '',
  'GatewayTimezone' => '',
  'CloudWatchLogGroupARN' => '',
  'GatewayCapacity' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "GatewayName": "",
  "GatewayTimezone": "",
  "CloudWatchLogGroupARN": "",
  "GatewayCapacity": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "GatewayName": "",
  "GatewayTimezone": "",
  "CloudWatchLogGroupARN": "",
  "GatewayCapacity": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"CloudWatchLogGroupARN\": \"\",\n  \"GatewayCapacity\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation"

payload = {
    "GatewayARN": "",
    "GatewayName": "",
    "GatewayTimezone": "",
    "CloudWatchLogGroupARN": "",
    "GatewayCapacity": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"CloudWatchLogGroupARN\": \"\",\n  \"GatewayCapacity\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"CloudWatchLogGroupARN\": \"\",\n  \"GatewayCapacity\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"GatewayName\": \"\",\n  \"GatewayTimezone\": \"\",\n  \"CloudWatchLogGroupARN\": \"\",\n  \"GatewayCapacity\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation";

    let payload = json!({
        "GatewayARN": "",
        "GatewayName": "",
        "GatewayTimezone": "",
        "CloudWatchLogGroupARN": "",
        "GatewayCapacity": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "GatewayName": "",
  "GatewayTimezone": "",
  "CloudWatchLogGroupARN": "",
  "GatewayCapacity": ""
}'

echo '{
  "GatewayARN": "",
  "GatewayName": "",
  "GatewayTimezone": "",
  "CloudWatchLogGroupARN": "",
  "GatewayCapacity": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "GatewayName": "",\n  "GatewayTimezone": "",\n  "CloudWatchLogGroupARN": "",\n  "GatewayCapacity": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "GatewayName": "",
  "GatewayTimezone": "",
  "CloudWatchLogGroupARN": "",
  "GatewayCapacity": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewayInformation")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "GatewayARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B",
  "GatewayName": ""
}

POST UpdateGatewaySoftwareNow

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:GatewayARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "GatewayARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\"\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  \"GatewayARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow",
  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([
    'GatewayARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow', [
  'body' => '{
  "GatewayARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow"

payload = { "GatewayARN": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow"

payload <- "{\n  \"GatewayARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow";

    let payload = json!({"GatewayARN": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": ""
}'

echo '{
  "GatewayARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["GatewayARN": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateGatewaySoftwareNow")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "GatewayARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B"
}

POST UpdateMaintenanceStartTime

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "HourOfDay": "",
  "MinuteOfHour": "",
  "DayOfWeek": "",
  "DayOfMonth": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\",\n  \"HourOfDay\": \"\",\n  \"MinuteOfHour\": \"\",\n  \"DayOfWeek\": \"\",\n  \"DayOfMonth\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:GatewayARN ""
                                                                                                                           :HourOfDay ""
                                                                                                                           :MinuteOfHour ""
                                                                                                                           :DayOfWeek ""
                                                                                                                           :DayOfMonth ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"HourOfDay\": \"\",\n  \"MinuteOfHour\": \"\",\n  \"DayOfWeek\": \"\",\n  \"DayOfMonth\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"HourOfDay\": \"\",\n  \"MinuteOfHour\": \"\",\n  \"DayOfWeek\": \"\",\n  \"DayOfMonth\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"HourOfDay\": \"\",\n  \"MinuteOfHour\": \"\",\n  \"DayOfWeek\": \"\",\n  \"DayOfMonth\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"HourOfDay\": \"\",\n  \"MinuteOfHour\": \"\",\n  \"DayOfWeek\": \"\",\n  \"DayOfMonth\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 102

{
  "GatewayARN": "",
  "HourOfDay": "",
  "MinuteOfHour": "",
  "DayOfWeek": "",
  "DayOfMonth": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"HourOfDay\": \"\",\n  \"MinuteOfHour\": \"\",\n  \"DayOfWeek\": \"\",\n  \"DayOfMonth\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"HourOfDay\": \"\",\n  \"MinuteOfHour\": \"\",\n  \"DayOfWeek\": \"\",\n  \"DayOfMonth\": \"\"\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  \"GatewayARN\": \"\",\n  \"HourOfDay\": \"\",\n  \"MinuteOfHour\": \"\",\n  \"DayOfWeek\": \"\",\n  \"DayOfMonth\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"HourOfDay\": \"\",\n  \"MinuteOfHour\": \"\",\n  \"DayOfWeek\": \"\",\n  \"DayOfMonth\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  HourOfDay: '',
  MinuteOfHour: '',
  DayOfWeek: '',
  DayOfMonth: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', HourOfDay: '', MinuteOfHour: '', DayOfWeek: '', DayOfMonth: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","HourOfDay":"","MinuteOfHour":"","DayOfWeek":"","DayOfMonth":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "HourOfDay": "",\n  "MinuteOfHour": "",\n  "DayOfWeek": "",\n  "DayOfMonth": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"HourOfDay\": \"\",\n  \"MinuteOfHour\": \"\",\n  \"DayOfWeek\": \"\",\n  \"DayOfMonth\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: '', HourOfDay: '', MinuteOfHour: '', DayOfWeek: '', DayOfMonth: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: '', HourOfDay: '', MinuteOfHour: '', DayOfWeek: '', DayOfMonth: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: '',
  HourOfDay: '',
  MinuteOfHour: '',
  DayOfWeek: '',
  DayOfMonth: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', HourOfDay: '', MinuteOfHour: '', DayOfWeek: '', DayOfMonth: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","HourOfDay":"","MinuteOfHour":"","DayOfWeek":"","DayOfMonth":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"HourOfDay": @"",
                              @"MinuteOfHour": @"",
                              @"DayOfWeek": @"",
                              @"DayOfMonth": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"HourOfDay\": \"\",\n  \"MinuteOfHour\": \"\",\n  \"DayOfWeek\": \"\",\n  \"DayOfMonth\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime",
  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([
    'GatewayARN' => '',
    'HourOfDay' => '',
    'MinuteOfHour' => '',
    'DayOfWeek' => '',
    'DayOfMonth' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime', [
  'body' => '{
  "GatewayARN": "",
  "HourOfDay": "",
  "MinuteOfHour": "",
  "DayOfWeek": "",
  "DayOfMonth": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => '',
  'HourOfDay' => '',
  'MinuteOfHour' => '',
  'DayOfWeek' => '',
  'DayOfMonth' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => '',
  'HourOfDay' => '',
  'MinuteOfHour' => '',
  'DayOfWeek' => '',
  'DayOfMonth' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "HourOfDay": "",
  "MinuteOfHour": "",
  "DayOfWeek": "",
  "DayOfMonth": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "HourOfDay": "",
  "MinuteOfHour": "",
  "DayOfWeek": "",
  "DayOfMonth": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\",\n  \"HourOfDay\": \"\",\n  \"MinuteOfHour\": \"\",\n  \"DayOfWeek\": \"\",\n  \"DayOfMonth\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime"

payload = {
    "GatewayARN": "",
    "HourOfDay": "",
    "MinuteOfHour": "",
    "DayOfWeek": "",
    "DayOfMonth": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"HourOfDay\": \"\",\n  \"MinuteOfHour\": \"\",\n  \"DayOfWeek\": \"\",\n  \"DayOfMonth\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"HourOfDay\": \"\",\n  \"MinuteOfHour\": \"\",\n  \"DayOfWeek\": \"\",\n  \"DayOfMonth\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"HourOfDay\": \"\",\n  \"MinuteOfHour\": \"\",\n  \"DayOfWeek\": \"\",\n  \"DayOfMonth\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime";

    let payload = json!({
        "GatewayARN": "",
        "HourOfDay": "",
        "MinuteOfHour": "",
        "DayOfWeek": "",
        "DayOfMonth": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "HourOfDay": "",
  "MinuteOfHour": "",
  "DayOfWeek": "",
  "DayOfMonth": ""
}'

echo '{
  "GatewayARN": "",
  "HourOfDay": "",
  "MinuteOfHour": "",
  "DayOfWeek": "",
  "DayOfMonth": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "HourOfDay": "",\n  "MinuteOfHour": "",\n  "DayOfWeek": "",\n  "DayOfMonth": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "HourOfDay": "",
  "MinuteOfHour": "",
  "DayOfWeek": "",
  "DayOfMonth": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateMaintenanceStartTime")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "GatewayARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B"
}

POST UpdateNFSFileShare

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare

HEADERS

X-Amz-Target

BODY json

{
  "FileShareARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "NFSFileShareDefaults": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ClientList": "",
  "Squash": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "AuditDestinationARN": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"AuditDestinationARN\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:FileShareARN ""
                                                                                                                   :KMSEncrypted ""
                                                                                                                   :KMSKey ""
                                                                                                                   :NFSFileShareDefaults ""
                                                                                                                   :DefaultStorageClass ""
                                                                                                                   :ObjectACL ""
                                                                                                                   :ClientList ""
                                                                                                                   :Squash ""
                                                                                                                   :ReadOnly ""
                                                                                                                   :GuessMIMETypeEnabled ""
                                                                                                                   :RequesterPays ""
                                                                                                                   :FileShareName ""
                                                                                                                   :CacheAttributes ""
                                                                                                                   :NotificationPolicy ""
                                                                                                                   :AuditDestinationARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"AuditDestinationARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"AuditDestinationARN\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"AuditDestinationARN\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare"

	payload := strings.NewReader("{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"AuditDestinationARN\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 352

{
  "FileShareARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "NFSFileShareDefaults": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ClientList": "",
  "Squash": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "AuditDestinationARN": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"AuditDestinationARN\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"AuditDestinationARN\": \"\"\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  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"AuditDestinationARN\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"AuditDestinationARN\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  FileShareARN: '',
  KMSEncrypted: '',
  KMSKey: '',
  NFSFileShareDefaults: '',
  DefaultStorageClass: '',
  ObjectACL: '',
  ClientList: '',
  Squash: '',
  ReadOnly: '',
  GuessMIMETypeEnabled: '',
  RequesterPays: '',
  FileShareName: '',
  CacheAttributes: '',
  NotificationPolicy: '',
  AuditDestinationARN: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    FileShareARN: '',
    KMSEncrypted: '',
    KMSKey: '',
    NFSFileShareDefaults: '',
    DefaultStorageClass: '',
    ObjectACL: '',
    ClientList: '',
    Squash: '',
    ReadOnly: '',
    GuessMIMETypeEnabled: '',
    RequesterPays: '',
    FileShareName: '',
    CacheAttributes: '',
    NotificationPolicy: '',
    AuditDestinationARN: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FileShareARN":"","KMSEncrypted":"","KMSKey":"","NFSFileShareDefaults":"","DefaultStorageClass":"","ObjectACL":"","ClientList":"","Squash":"","ReadOnly":"","GuessMIMETypeEnabled":"","RequesterPays":"","FileShareName":"","CacheAttributes":"","NotificationPolicy":"","AuditDestinationARN":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "FileShareARN": "",\n  "KMSEncrypted": "",\n  "KMSKey": "",\n  "NFSFileShareDefaults": "",\n  "DefaultStorageClass": "",\n  "ObjectACL": "",\n  "ClientList": "",\n  "Squash": "",\n  "ReadOnly": "",\n  "GuessMIMETypeEnabled": "",\n  "RequesterPays": "",\n  "FileShareName": "",\n  "CacheAttributes": "",\n  "NotificationPolicy": "",\n  "AuditDestinationARN": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"AuditDestinationARN\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({
  FileShareARN: '',
  KMSEncrypted: '',
  KMSKey: '',
  NFSFileShareDefaults: '',
  DefaultStorageClass: '',
  ObjectACL: '',
  ClientList: '',
  Squash: '',
  ReadOnly: '',
  GuessMIMETypeEnabled: '',
  RequesterPays: '',
  FileShareName: '',
  CacheAttributes: '',
  NotificationPolicy: '',
  AuditDestinationARN: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    FileShareARN: '',
    KMSEncrypted: '',
    KMSKey: '',
    NFSFileShareDefaults: '',
    DefaultStorageClass: '',
    ObjectACL: '',
    ClientList: '',
    Squash: '',
    ReadOnly: '',
    GuessMIMETypeEnabled: '',
    RequesterPays: '',
    FileShareName: '',
    CacheAttributes: '',
    NotificationPolicy: '',
    AuditDestinationARN: ''
  },
  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}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  FileShareARN: '',
  KMSEncrypted: '',
  KMSKey: '',
  NFSFileShareDefaults: '',
  DefaultStorageClass: '',
  ObjectACL: '',
  ClientList: '',
  Squash: '',
  ReadOnly: '',
  GuessMIMETypeEnabled: '',
  RequesterPays: '',
  FileShareName: '',
  CacheAttributes: '',
  NotificationPolicy: '',
  AuditDestinationARN: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    FileShareARN: '',
    KMSEncrypted: '',
    KMSKey: '',
    NFSFileShareDefaults: '',
    DefaultStorageClass: '',
    ObjectACL: '',
    ClientList: '',
    Squash: '',
    ReadOnly: '',
    GuessMIMETypeEnabled: '',
    RequesterPays: '',
    FileShareName: '',
    CacheAttributes: '',
    NotificationPolicy: '',
    AuditDestinationARN: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FileShareARN":"","KMSEncrypted":"","KMSKey":"","NFSFileShareDefaults":"","DefaultStorageClass":"","ObjectACL":"","ClientList":"","Squash":"","ReadOnly":"","GuessMIMETypeEnabled":"","RequesterPays":"","FileShareName":"","CacheAttributes":"","NotificationPolicy":"","AuditDestinationARN":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"FileShareARN": @"",
                              @"KMSEncrypted": @"",
                              @"KMSKey": @"",
                              @"NFSFileShareDefaults": @"",
                              @"DefaultStorageClass": @"",
                              @"ObjectACL": @"",
                              @"ClientList": @"",
                              @"Squash": @"",
                              @"ReadOnly": @"",
                              @"GuessMIMETypeEnabled": @"",
                              @"RequesterPays": @"",
                              @"FileShareName": @"",
                              @"CacheAttributes": @"",
                              @"NotificationPolicy": @"",
                              @"AuditDestinationARN": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"AuditDestinationARN\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare",
  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([
    'FileShareARN' => '',
    'KMSEncrypted' => '',
    'KMSKey' => '',
    'NFSFileShareDefaults' => '',
    'DefaultStorageClass' => '',
    'ObjectACL' => '',
    'ClientList' => '',
    'Squash' => '',
    'ReadOnly' => '',
    'GuessMIMETypeEnabled' => '',
    'RequesterPays' => '',
    'FileShareName' => '',
    'CacheAttributes' => '',
    'NotificationPolicy' => '',
    'AuditDestinationARN' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare', [
  'body' => '{
  "FileShareARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "NFSFileShareDefaults": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ClientList": "",
  "Squash": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "AuditDestinationARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'FileShareARN' => '',
  'KMSEncrypted' => '',
  'KMSKey' => '',
  'NFSFileShareDefaults' => '',
  'DefaultStorageClass' => '',
  'ObjectACL' => '',
  'ClientList' => '',
  'Squash' => '',
  'ReadOnly' => '',
  'GuessMIMETypeEnabled' => '',
  'RequesterPays' => '',
  'FileShareName' => '',
  'CacheAttributes' => '',
  'NotificationPolicy' => '',
  'AuditDestinationARN' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'FileShareARN' => '',
  'KMSEncrypted' => '',
  'KMSKey' => '',
  'NFSFileShareDefaults' => '',
  'DefaultStorageClass' => '',
  'ObjectACL' => '',
  'ClientList' => '',
  'Squash' => '',
  'ReadOnly' => '',
  'GuessMIMETypeEnabled' => '',
  'RequesterPays' => '',
  'FileShareName' => '',
  'CacheAttributes' => '',
  'NotificationPolicy' => '',
  'AuditDestinationARN' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FileShareARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "NFSFileShareDefaults": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ClientList": "",
  "Squash": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "AuditDestinationARN": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FileShareARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "NFSFileShareDefaults": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ClientList": "",
  "Squash": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "AuditDestinationARN": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"AuditDestinationARN\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare"

payload = {
    "FileShareARN": "",
    "KMSEncrypted": "",
    "KMSKey": "",
    "NFSFileShareDefaults": "",
    "DefaultStorageClass": "",
    "ObjectACL": "",
    "ClientList": "",
    "Squash": "",
    "ReadOnly": "",
    "GuessMIMETypeEnabled": "",
    "RequesterPays": "",
    "FileShareName": "",
    "CacheAttributes": "",
    "NotificationPolicy": "",
    "AuditDestinationARN": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare"

payload <- "{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"AuditDestinationARN\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"AuditDestinationARN\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"NFSFileShareDefaults\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ClientList\": \"\",\n  \"Squash\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"AuditDestinationARN\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare";

    let payload = json!({
        "FileShareARN": "",
        "KMSEncrypted": "",
        "KMSKey": "",
        "NFSFileShareDefaults": "",
        "DefaultStorageClass": "",
        "ObjectACL": "",
        "ClientList": "",
        "Squash": "",
        "ReadOnly": "",
        "GuessMIMETypeEnabled": "",
        "RequesterPays": "",
        "FileShareName": "",
        "CacheAttributes": "",
        "NotificationPolicy": "",
        "AuditDestinationARN": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "FileShareARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "NFSFileShareDefaults": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ClientList": "",
  "Squash": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "AuditDestinationARN": ""
}'

echo '{
  "FileShareARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "NFSFileShareDefaults": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ClientList": "",
  "Squash": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "AuditDestinationARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "FileShareARN": "",\n  "KMSEncrypted": "",\n  "KMSKey": "",\n  "NFSFileShareDefaults": "",\n  "DefaultStorageClass": "",\n  "ObjectACL": "",\n  "ClientList": "",\n  "Squash": "",\n  "ReadOnly": "",\n  "GuessMIMETypeEnabled": "",\n  "RequesterPays": "",\n  "FileShareName": "",\n  "CacheAttributes": "",\n  "NotificationPolicy": "",\n  "AuditDestinationARN": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "FileShareARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "NFSFileShareDefaults": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ClientList": "",
  "Squash": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "AuditDestinationARN": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateNFSFileShare")! 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 UpdateSMBFileShare

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare

HEADERS

X-Amz-Target

BODY json

{
  "FileShareARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "SMBACLEnabled": "",
  "AccessBasedEnumeration": "",
  "AdminUserList": "",
  "ValidUserList": "",
  "InvalidUserList": "",
  "AuditDestinationARN": "",
  "CaseSensitivity": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "OplocksEnabled": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"OplocksEnabled\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:FileShareARN ""
                                                                                                                   :KMSEncrypted ""
                                                                                                                   :KMSKey ""
                                                                                                                   :DefaultStorageClass ""
                                                                                                                   :ObjectACL ""
                                                                                                                   :ReadOnly ""
                                                                                                                   :GuessMIMETypeEnabled ""
                                                                                                                   :RequesterPays ""
                                                                                                                   :SMBACLEnabled ""
                                                                                                                   :AccessBasedEnumeration ""
                                                                                                                   :AdminUserList ""
                                                                                                                   :ValidUserList ""
                                                                                                                   :InvalidUserList ""
                                                                                                                   :AuditDestinationARN ""
                                                                                                                   :CaseSensitivity ""
                                                                                                                   :FileShareName ""
                                                                                                                   :CacheAttributes ""
                                                                                                                   :NotificationPolicy ""
                                                                                                                   :OplocksEnabled ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"OplocksEnabled\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"OplocksEnabled\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"OplocksEnabled\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare"

	payload := strings.NewReader("{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"OplocksEnabled\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 461

{
  "FileShareARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "SMBACLEnabled": "",
  "AccessBasedEnumeration": "",
  "AdminUserList": "",
  "ValidUserList": "",
  "InvalidUserList": "",
  "AuditDestinationARN": "",
  "CaseSensitivity": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "OplocksEnabled": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"OplocksEnabled\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"OplocksEnabled\": \"\"\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  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"OplocksEnabled\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"OplocksEnabled\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  FileShareARN: '',
  KMSEncrypted: '',
  KMSKey: '',
  DefaultStorageClass: '',
  ObjectACL: '',
  ReadOnly: '',
  GuessMIMETypeEnabled: '',
  RequesterPays: '',
  SMBACLEnabled: '',
  AccessBasedEnumeration: '',
  AdminUserList: '',
  ValidUserList: '',
  InvalidUserList: '',
  AuditDestinationARN: '',
  CaseSensitivity: '',
  FileShareName: '',
  CacheAttributes: '',
  NotificationPolicy: '',
  OplocksEnabled: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    FileShareARN: '',
    KMSEncrypted: '',
    KMSKey: '',
    DefaultStorageClass: '',
    ObjectACL: '',
    ReadOnly: '',
    GuessMIMETypeEnabled: '',
    RequesterPays: '',
    SMBACLEnabled: '',
    AccessBasedEnumeration: '',
    AdminUserList: '',
    ValidUserList: '',
    InvalidUserList: '',
    AuditDestinationARN: '',
    CaseSensitivity: '',
    FileShareName: '',
    CacheAttributes: '',
    NotificationPolicy: '',
    OplocksEnabled: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FileShareARN":"","KMSEncrypted":"","KMSKey":"","DefaultStorageClass":"","ObjectACL":"","ReadOnly":"","GuessMIMETypeEnabled":"","RequesterPays":"","SMBACLEnabled":"","AccessBasedEnumeration":"","AdminUserList":"","ValidUserList":"","InvalidUserList":"","AuditDestinationARN":"","CaseSensitivity":"","FileShareName":"","CacheAttributes":"","NotificationPolicy":"","OplocksEnabled":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "FileShareARN": "",\n  "KMSEncrypted": "",\n  "KMSKey": "",\n  "DefaultStorageClass": "",\n  "ObjectACL": "",\n  "ReadOnly": "",\n  "GuessMIMETypeEnabled": "",\n  "RequesterPays": "",\n  "SMBACLEnabled": "",\n  "AccessBasedEnumeration": "",\n  "AdminUserList": "",\n  "ValidUserList": "",\n  "InvalidUserList": "",\n  "AuditDestinationARN": "",\n  "CaseSensitivity": "",\n  "FileShareName": "",\n  "CacheAttributes": "",\n  "NotificationPolicy": "",\n  "OplocksEnabled": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"OplocksEnabled\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({
  FileShareARN: '',
  KMSEncrypted: '',
  KMSKey: '',
  DefaultStorageClass: '',
  ObjectACL: '',
  ReadOnly: '',
  GuessMIMETypeEnabled: '',
  RequesterPays: '',
  SMBACLEnabled: '',
  AccessBasedEnumeration: '',
  AdminUserList: '',
  ValidUserList: '',
  InvalidUserList: '',
  AuditDestinationARN: '',
  CaseSensitivity: '',
  FileShareName: '',
  CacheAttributes: '',
  NotificationPolicy: '',
  OplocksEnabled: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    FileShareARN: '',
    KMSEncrypted: '',
    KMSKey: '',
    DefaultStorageClass: '',
    ObjectACL: '',
    ReadOnly: '',
    GuessMIMETypeEnabled: '',
    RequesterPays: '',
    SMBACLEnabled: '',
    AccessBasedEnumeration: '',
    AdminUserList: '',
    ValidUserList: '',
    InvalidUserList: '',
    AuditDestinationARN: '',
    CaseSensitivity: '',
    FileShareName: '',
    CacheAttributes: '',
    NotificationPolicy: '',
    OplocksEnabled: ''
  },
  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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  FileShareARN: '',
  KMSEncrypted: '',
  KMSKey: '',
  DefaultStorageClass: '',
  ObjectACL: '',
  ReadOnly: '',
  GuessMIMETypeEnabled: '',
  RequesterPays: '',
  SMBACLEnabled: '',
  AccessBasedEnumeration: '',
  AdminUserList: '',
  ValidUserList: '',
  InvalidUserList: '',
  AuditDestinationARN: '',
  CaseSensitivity: '',
  FileShareName: '',
  CacheAttributes: '',
  NotificationPolicy: '',
  OplocksEnabled: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    FileShareARN: '',
    KMSEncrypted: '',
    KMSKey: '',
    DefaultStorageClass: '',
    ObjectACL: '',
    ReadOnly: '',
    GuessMIMETypeEnabled: '',
    RequesterPays: '',
    SMBACLEnabled: '',
    AccessBasedEnumeration: '',
    AdminUserList: '',
    ValidUserList: '',
    InvalidUserList: '',
    AuditDestinationARN: '',
    CaseSensitivity: '',
    FileShareName: '',
    CacheAttributes: '',
    NotificationPolicy: '',
    OplocksEnabled: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"FileShareARN":"","KMSEncrypted":"","KMSKey":"","DefaultStorageClass":"","ObjectACL":"","ReadOnly":"","GuessMIMETypeEnabled":"","RequesterPays":"","SMBACLEnabled":"","AccessBasedEnumeration":"","AdminUserList":"","ValidUserList":"","InvalidUserList":"","AuditDestinationARN":"","CaseSensitivity":"","FileShareName":"","CacheAttributes":"","NotificationPolicy":"","OplocksEnabled":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"FileShareARN": @"",
                              @"KMSEncrypted": @"",
                              @"KMSKey": @"",
                              @"DefaultStorageClass": @"",
                              @"ObjectACL": @"",
                              @"ReadOnly": @"",
                              @"GuessMIMETypeEnabled": @"",
                              @"RequesterPays": @"",
                              @"SMBACLEnabled": @"",
                              @"AccessBasedEnumeration": @"",
                              @"AdminUserList": @"",
                              @"ValidUserList": @"",
                              @"InvalidUserList": @"",
                              @"AuditDestinationARN": @"",
                              @"CaseSensitivity": @"",
                              @"FileShareName": @"",
                              @"CacheAttributes": @"",
                              @"NotificationPolicy": @"",
                              @"OplocksEnabled": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"OplocksEnabled\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare",
  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([
    'FileShareARN' => '',
    'KMSEncrypted' => '',
    'KMSKey' => '',
    'DefaultStorageClass' => '',
    'ObjectACL' => '',
    'ReadOnly' => '',
    'GuessMIMETypeEnabled' => '',
    'RequesterPays' => '',
    'SMBACLEnabled' => '',
    'AccessBasedEnumeration' => '',
    'AdminUserList' => '',
    'ValidUserList' => '',
    'InvalidUserList' => '',
    'AuditDestinationARN' => '',
    'CaseSensitivity' => '',
    'FileShareName' => '',
    'CacheAttributes' => '',
    'NotificationPolicy' => '',
    'OplocksEnabled' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare', [
  'body' => '{
  "FileShareARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "SMBACLEnabled": "",
  "AccessBasedEnumeration": "",
  "AdminUserList": "",
  "ValidUserList": "",
  "InvalidUserList": "",
  "AuditDestinationARN": "",
  "CaseSensitivity": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "OplocksEnabled": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'FileShareARN' => '',
  'KMSEncrypted' => '',
  'KMSKey' => '',
  'DefaultStorageClass' => '',
  'ObjectACL' => '',
  'ReadOnly' => '',
  'GuessMIMETypeEnabled' => '',
  'RequesterPays' => '',
  'SMBACLEnabled' => '',
  'AccessBasedEnumeration' => '',
  'AdminUserList' => '',
  'ValidUserList' => '',
  'InvalidUserList' => '',
  'AuditDestinationARN' => '',
  'CaseSensitivity' => '',
  'FileShareName' => '',
  'CacheAttributes' => '',
  'NotificationPolicy' => '',
  'OplocksEnabled' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'FileShareARN' => '',
  'KMSEncrypted' => '',
  'KMSKey' => '',
  'DefaultStorageClass' => '',
  'ObjectACL' => '',
  'ReadOnly' => '',
  'GuessMIMETypeEnabled' => '',
  'RequesterPays' => '',
  'SMBACLEnabled' => '',
  'AccessBasedEnumeration' => '',
  'AdminUserList' => '',
  'ValidUserList' => '',
  'InvalidUserList' => '',
  'AuditDestinationARN' => '',
  'CaseSensitivity' => '',
  'FileShareName' => '',
  'CacheAttributes' => '',
  'NotificationPolicy' => '',
  'OplocksEnabled' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FileShareARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "SMBACLEnabled": "",
  "AccessBasedEnumeration": "",
  "AdminUserList": "",
  "ValidUserList": "",
  "InvalidUserList": "",
  "AuditDestinationARN": "",
  "CaseSensitivity": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "OplocksEnabled": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "FileShareARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "SMBACLEnabled": "",
  "AccessBasedEnumeration": "",
  "AdminUserList": "",
  "ValidUserList": "",
  "InvalidUserList": "",
  "AuditDestinationARN": "",
  "CaseSensitivity": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "OplocksEnabled": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"OplocksEnabled\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare"

payload = {
    "FileShareARN": "",
    "KMSEncrypted": "",
    "KMSKey": "",
    "DefaultStorageClass": "",
    "ObjectACL": "",
    "ReadOnly": "",
    "GuessMIMETypeEnabled": "",
    "RequesterPays": "",
    "SMBACLEnabled": "",
    "AccessBasedEnumeration": "",
    "AdminUserList": "",
    "ValidUserList": "",
    "InvalidUserList": "",
    "AuditDestinationARN": "",
    "CaseSensitivity": "",
    "FileShareName": "",
    "CacheAttributes": "",
    "NotificationPolicy": "",
    "OplocksEnabled": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare"

payload <- "{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"OplocksEnabled\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"OplocksEnabled\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"FileShareARN\": \"\",\n  \"KMSEncrypted\": \"\",\n  \"KMSKey\": \"\",\n  \"DefaultStorageClass\": \"\",\n  \"ObjectACL\": \"\",\n  \"ReadOnly\": \"\",\n  \"GuessMIMETypeEnabled\": \"\",\n  \"RequesterPays\": \"\",\n  \"SMBACLEnabled\": \"\",\n  \"AccessBasedEnumeration\": \"\",\n  \"AdminUserList\": \"\",\n  \"ValidUserList\": \"\",\n  \"InvalidUserList\": \"\",\n  \"AuditDestinationARN\": \"\",\n  \"CaseSensitivity\": \"\",\n  \"FileShareName\": \"\",\n  \"CacheAttributes\": \"\",\n  \"NotificationPolicy\": \"\",\n  \"OplocksEnabled\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare";

    let payload = json!({
        "FileShareARN": "",
        "KMSEncrypted": "",
        "KMSKey": "",
        "DefaultStorageClass": "",
        "ObjectACL": "",
        "ReadOnly": "",
        "GuessMIMETypeEnabled": "",
        "RequesterPays": "",
        "SMBACLEnabled": "",
        "AccessBasedEnumeration": "",
        "AdminUserList": "",
        "ValidUserList": "",
        "InvalidUserList": "",
        "AuditDestinationARN": "",
        "CaseSensitivity": "",
        "FileShareName": "",
        "CacheAttributes": "",
        "NotificationPolicy": "",
        "OplocksEnabled": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "FileShareARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "SMBACLEnabled": "",
  "AccessBasedEnumeration": "",
  "AdminUserList": "",
  "ValidUserList": "",
  "InvalidUserList": "",
  "AuditDestinationARN": "",
  "CaseSensitivity": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "OplocksEnabled": ""
}'

echo '{
  "FileShareARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "SMBACLEnabled": "",
  "AccessBasedEnumeration": "",
  "AdminUserList": "",
  "ValidUserList": "",
  "InvalidUserList": "",
  "AuditDestinationARN": "",
  "CaseSensitivity": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "OplocksEnabled": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "FileShareARN": "",\n  "KMSEncrypted": "",\n  "KMSKey": "",\n  "DefaultStorageClass": "",\n  "ObjectACL": "",\n  "ReadOnly": "",\n  "GuessMIMETypeEnabled": "",\n  "RequesterPays": "",\n  "SMBACLEnabled": "",\n  "AccessBasedEnumeration": "",\n  "AdminUserList": "",\n  "ValidUserList": "",\n  "InvalidUserList": "",\n  "AuditDestinationARN": "",\n  "CaseSensitivity": "",\n  "FileShareName": "",\n  "CacheAttributes": "",\n  "NotificationPolicy": "",\n  "OplocksEnabled": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "FileShareARN": "",
  "KMSEncrypted": "",
  "KMSKey": "",
  "DefaultStorageClass": "",
  "ObjectACL": "",
  "ReadOnly": "",
  "GuessMIMETypeEnabled": "",
  "RequesterPays": "",
  "SMBACLEnabled": "",
  "AccessBasedEnumeration": "",
  "AdminUserList": "",
  "ValidUserList": "",
  "InvalidUserList": "",
  "AuditDestinationARN": "",
  "CaseSensitivity": "",
  "FileShareName": "",
  "CacheAttributes": "",
  "NotificationPolicy": "",
  "OplocksEnabled": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShare")! 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 UpdateSMBFileShareVisibility

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "FileSharesVisible": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\",\n  \"FileSharesVisible\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:GatewayARN ""
                                                                                                                             :FileSharesVisible ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"FileSharesVisible\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"FileSharesVisible\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"FileSharesVisible\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"FileSharesVisible\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 49

{
  "GatewayARN": "",
  "FileSharesVisible": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"FileSharesVisible\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"FileSharesVisible\": \"\"\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  \"GatewayARN\": \"\",\n  \"FileSharesVisible\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"FileSharesVisible\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  FileSharesVisible: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', FileSharesVisible: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","FileSharesVisible":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "FileSharesVisible": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"FileSharesVisible\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: '', FileSharesVisible: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: '', FileSharesVisible: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: '',
  FileSharesVisible: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', FileSharesVisible: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","FileSharesVisible":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"FileSharesVisible": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"FileSharesVisible\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility",
  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([
    'GatewayARN' => '',
    'FileSharesVisible' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility', [
  'body' => '{
  "GatewayARN": "",
  "FileSharesVisible": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => '',
  'FileSharesVisible' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => '',
  'FileSharesVisible' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "FileSharesVisible": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "FileSharesVisible": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\",\n  \"FileSharesVisible\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility"

payload = {
    "GatewayARN": "",
    "FileSharesVisible": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"FileSharesVisible\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"FileSharesVisible\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"FileSharesVisible\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility";

    let payload = json!({
        "GatewayARN": "",
        "FileSharesVisible": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "FileSharesVisible": ""
}'

echo '{
  "GatewayARN": "",
  "FileSharesVisible": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "FileSharesVisible": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "FileSharesVisible": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBFileShareVisibility")! 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 UpdateSMBLocalGroups

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "SMBLocalGroups": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\",\n  \"SMBLocalGroups\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:GatewayARN ""
                                                                                                                     :SMBLocalGroups ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"SMBLocalGroups\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"SMBLocalGroups\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"SMBLocalGroups\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"SMBLocalGroups\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 46

{
  "GatewayARN": "",
  "SMBLocalGroups": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"SMBLocalGroups\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"SMBLocalGroups\": \"\"\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  \"GatewayARN\": \"\",\n  \"SMBLocalGroups\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"SMBLocalGroups\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  SMBLocalGroups: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', SMBLocalGroups: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","SMBLocalGroups":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "SMBLocalGroups": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"SMBLocalGroups\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: '', SMBLocalGroups: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: '', SMBLocalGroups: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: '',
  SMBLocalGroups: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', SMBLocalGroups: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","SMBLocalGroups":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"SMBLocalGroups": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"SMBLocalGroups\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups",
  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([
    'GatewayARN' => '',
    'SMBLocalGroups' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups', [
  'body' => '{
  "GatewayARN": "",
  "SMBLocalGroups": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => '',
  'SMBLocalGroups' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => '',
  'SMBLocalGroups' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "SMBLocalGroups": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "SMBLocalGroups": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\",\n  \"SMBLocalGroups\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups"

payload = {
    "GatewayARN": "",
    "SMBLocalGroups": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"SMBLocalGroups\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"SMBLocalGroups\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"SMBLocalGroups\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups";

    let payload = json!({
        "GatewayARN": "",
        "SMBLocalGroups": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "SMBLocalGroups": ""
}'

echo '{
  "GatewayARN": "",
  "SMBLocalGroups": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "SMBLocalGroups": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "SMBLocalGroups": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBLocalGroups")! 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 UpdateSMBSecurityStrategy

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy

HEADERS

X-Amz-Target

BODY json

{
  "GatewayARN": "",
  "SMBSecurityStrategy": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"GatewayARN\": \"\",\n  \"SMBSecurityStrategy\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:GatewayARN ""
                                                                                                                          :SMBSecurityStrategy ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"GatewayARN\": \"\",\n  \"SMBSecurityStrategy\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"GatewayARN\": \"\",\n  \"SMBSecurityStrategy\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"GatewayARN\": \"\",\n  \"SMBSecurityStrategy\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy"

	payload := strings.NewReader("{\n  \"GatewayARN\": \"\",\n  \"SMBSecurityStrategy\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 51

{
  "GatewayARN": "",
  "SMBSecurityStrategy": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"GatewayARN\": \"\",\n  \"SMBSecurityStrategy\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GatewayARN\": \"\",\n  \"SMBSecurityStrategy\": \"\"\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  \"GatewayARN\": \"\",\n  \"SMBSecurityStrategy\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GatewayARN\": \"\",\n  \"SMBSecurityStrategy\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GatewayARN: '',
  SMBSecurityStrategy: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', SMBSecurityStrategy: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","SMBSecurityStrategy":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GatewayARN": "",\n  "SMBSecurityStrategy": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GatewayARN\": \"\",\n  \"SMBSecurityStrategy\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({GatewayARN: '', SMBSecurityStrategy: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GatewayARN: '', SMBSecurityStrategy: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  GatewayARN: '',
  SMBSecurityStrategy: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GatewayARN: '', SMBSecurityStrategy: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GatewayARN":"","SMBSecurityStrategy":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"GatewayARN": @"",
                              @"SMBSecurityStrategy": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"GatewayARN\": \"\",\n  \"SMBSecurityStrategy\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy",
  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([
    'GatewayARN' => '',
    'SMBSecurityStrategy' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy', [
  'body' => '{
  "GatewayARN": "",
  "SMBSecurityStrategy": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GatewayARN' => '',
  'SMBSecurityStrategy' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'GatewayARN' => '',
  'SMBSecurityStrategy' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "SMBSecurityStrategy": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GatewayARN": "",
  "SMBSecurityStrategy": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"GatewayARN\": \"\",\n  \"SMBSecurityStrategy\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy"

payload = {
    "GatewayARN": "",
    "SMBSecurityStrategy": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy"

payload <- "{\n  \"GatewayARN\": \"\",\n  \"SMBSecurityStrategy\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"GatewayARN\": \"\",\n  \"SMBSecurityStrategy\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"GatewayARN\": \"\",\n  \"SMBSecurityStrategy\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy";

    let payload = json!({
        "GatewayARN": "",
        "SMBSecurityStrategy": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GatewayARN": "",
  "SMBSecurityStrategy": ""
}'

echo '{
  "GatewayARN": "",
  "SMBSecurityStrategy": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GatewayARN": "",\n  "SMBSecurityStrategy": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "GatewayARN": "",
  "SMBSecurityStrategy": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSMBSecurityStrategy")! 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 UpdateSnapshotSchedule

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule

HEADERS

X-Amz-Target

BODY json

{
  "VolumeARN": "",
  "StartAt": "",
  "RecurrenceInHours": "",
  "Description": "",
  "Tags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"VolumeARN\": \"\",\n  \"StartAt\": \"\",\n  \"RecurrenceInHours\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:VolumeARN ""
                                                                                                                       :StartAt ""
                                                                                                                       :RecurrenceInHours ""
                                                                                                                       :Description ""
                                                                                                                       :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"VolumeARN\": \"\",\n  \"StartAt\": \"\",\n  \"RecurrenceInHours\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"VolumeARN\": \"\",\n  \"StartAt\": \"\",\n  \"RecurrenceInHours\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"VolumeARN\": \"\",\n  \"StartAt\": \"\",\n  \"RecurrenceInHours\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule"

	payload := strings.NewReader("{\n  \"VolumeARN\": \"\",\n  \"StartAt\": \"\",\n  \"RecurrenceInHours\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 100

{
  "VolumeARN": "",
  "StartAt": "",
  "RecurrenceInHours": "",
  "Description": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"VolumeARN\": \"\",\n  \"StartAt\": \"\",\n  \"RecurrenceInHours\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"VolumeARN\": \"\",\n  \"StartAt\": \"\",\n  \"RecurrenceInHours\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"VolumeARN\": \"\",\n  \"StartAt\": \"\",\n  \"RecurrenceInHours\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"VolumeARN\": \"\",\n  \"StartAt\": \"\",\n  \"RecurrenceInHours\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  VolumeARN: '',
  StartAt: '',
  RecurrenceInHours: '',
  Description: '',
  Tags: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {VolumeARN: '', StartAt: '', RecurrenceInHours: '', Description: '', Tags: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"VolumeARN":"","StartAt":"","RecurrenceInHours":"","Description":"","Tags":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "VolumeARN": "",\n  "StartAt": "",\n  "RecurrenceInHours": "",\n  "Description": "",\n  "Tags": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"VolumeARN\": \"\",\n  \"StartAt\": \"\",\n  \"RecurrenceInHours\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({VolumeARN: '', StartAt: '', RecurrenceInHours: '', Description: '', Tags: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {VolumeARN: '', StartAt: '', RecurrenceInHours: '', Description: '', Tags: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  VolumeARN: '',
  StartAt: '',
  RecurrenceInHours: '',
  Description: '',
  Tags: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {VolumeARN: '', StartAt: '', RecurrenceInHours: '', Description: '', Tags: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"VolumeARN":"","StartAt":"","RecurrenceInHours":"","Description":"","Tags":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"VolumeARN": @"",
                              @"StartAt": @"",
                              @"RecurrenceInHours": @"",
                              @"Description": @"",
                              @"Tags": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"VolumeARN\": \"\",\n  \"StartAt\": \"\",\n  \"RecurrenceInHours\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule",
  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([
    'VolumeARN' => '',
    'StartAt' => '',
    'RecurrenceInHours' => '',
    'Description' => '',
    'Tags' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule', [
  'body' => '{
  "VolumeARN": "",
  "StartAt": "",
  "RecurrenceInHours": "",
  "Description": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'VolumeARN' => '',
  'StartAt' => '',
  'RecurrenceInHours' => '',
  'Description' => '',
  'Tags' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'VolumeARN' => '',
  'StartAt' => '',
  'RecurrenceInHours' => '',
  'Description' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "VolumeARN": "",
  "StartAt": "",
  "RecurrenceInHours": "",
  "Description": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "VolumeARN": "",
  "StartAt": "",
  "RecurrenceInHours": "",
  "Description": "",
  "Tags": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"VolumeARN\": \"\",\n  \"StartAt\": \"\",\n  \"RecurrenceInHours\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule"

payload = {
    "VolumeARN": "",
    "StartAt": "",
    "RecurrenceInHours": "",
    "Description": "",
    "Tags": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule"

payload <- "{\n  \"VolumeARN\": \"\",\n  \"StartAt\": \"\",\n  \"RecurrenceInHours\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"VolumeARN\": \"\",\n  \"StartAt\": \"\",\n  \"RecurrenceInHours\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"VolumeARN\": \"\",\n  \"StartAt\": \"\",\n  \"RecurrenceInHours\": \"\",\n  \"Description\": \"\",\n  \"Tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule";

    let payload = json!({
        "VolumeARN": "",
        "StartAt": "",
        "RecurrenceInHours": "",
        "Description": "",
        "Tags": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "VolumeARN": "",
  "StartAt": "",
  "RecurrenceInHours": "",
  "Description": "",
  "Tags": ""
}'

echo '{
  "VolumeARN": "",
  "StartAt": "",
  "RecurrenceInHours": "",
  "Description": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "VolumeARN": "",\n  "StartAt": "",\n  "RecurrenceInHours": "",\n  "Description": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "VolumeARN": "",
  "StartAt": "",
  "RecurrenceInHours": "",
  "Description": "",
  "Tags": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateSnapshotSchedule")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "VolumeARN": "arn:aws:storagegateway:us-east-1:111122223333:gateway/sgw-12A3456B/volume/vol-1122AABB"
}

POST UpdateVTLDeviceType

{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType

HEADERS

X-Amz-Target

BODY json

{
  "VTLDeviceARN": "",
  "DeviceType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"VTLDeviceARN\": \"\",\n  \"DeviceType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:VTLDeviceARN ""
                                                                                                                    :DeviceType ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"VTLDeviceARN\": \"\",\n  \"DeviceType\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"VTLDeviceARN\": \"\",\n  \"DeviceType\": \"\"\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}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"VTLDeviceARN\": \"\",\n  \"DeviceType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType"

	payload := strings.NewReader("{\n  \"VTLDeviceARN\": \"\",\n  \"DeviceType\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	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/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 44

{
  "VTLDeviceARN": "",
  "DeviceType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"VTLDeviceARN\": \"\",\n  \"DeviceType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"VTLDeviceARN\": \"\",\n  \"DeviceType\": \"\"\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  \"VTLDeviceARN\": \"\",\n  \"DeviceType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"VTLDeviceARN\": \"\",\n  \"DeviceType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  VTLDeviceARN: '',
  DeviceType: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {VTLDeviceARN: '', DeviceType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"VTLDeviceARN":"","DeviceType":""}'
};

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "VTLDeviceARN": "",\n  "DeviceType": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"VTLDeviceARN\": \"\",\n  \"DeviceType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType")
  .post(body)
  .addHeader("x-amz-target", "")
  .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/',
  headers: {
    'x-amz-target': '',
    '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({VTLDeviceARN: '', DeviceType: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {VTLDeviceARN: '', DeviceType: ''},
  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}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  VTLDeviceARN: '',
  DeviceType: ''
});

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}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {VTLDeviceARN: '', DeviceType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"VTLDeviceARN":"","DeviceType":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"VTLDeviceARN": @"",
                              @"DeviceType": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType"]
                                                       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}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"VTLDeviceARN\": \"\",\n  \"DeviceType\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType",
  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([
    'VTLDeviceARN' => '',
    'DeviceType' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType', [
  'body' => '{
  "VTLDeviceARN": "",
  "DeviceType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'VTLDeviceARN' => '',
  'DeviceType' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'VTLDeviceARN' => '',
  'DeviceType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "VTLDeviceARN": "",
  "DeviceType": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "VTLDeviceARN": "",
  "DeviceType": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"VTLDeviceARN\": \"\",\n  \"DeviceType\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType"

payload = {
    "VTLDeviceARN": "",
    "DeviceType": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType"

payload <- "{\n  \"VTLDeviceARN\": \"\",\n  \"DeviceType\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"VTLDeviceARN\": \"\",\n  \"DeviceType\": \"\"\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/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"VTLDeviceARN\": \"\",\n  \"DeviceType\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType";

    let payload = json!({
        "VTLDeviceARN": "",
        "DeviceType": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    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}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "VTLDeviceARN": "",
  "DeviceType": ""
}'

echo '{
  "VTLDeviceARN": "",
  "DeviceType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "VTLDeviceARN": "",\n  "DeviceType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "VTLDeviceARN": "",
  "DeviceType": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=StorageGateway_20130630.UpdateVTLDeviceType")! 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()

RESPONSE HEADERS

Content-Type

application/json

RESPONSE BODY json

{
  "VTLDeviceARN": "arn:aws:storagegateway:us-east-1:999999999999:gateway/sgw-12A3456B/device/AMZN_SGW-1FAD4876_MEDIACHANGER_00001"
}