AWS CloudTrail

POST AddTags

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags

HEADERS

X-Amz-Target

BODY json

{
  "ResourceId": "",
  "TagsList": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags");

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  \"ResourceId\": \"\",\n  \"TagsList\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags" {:headers {:x-amz-target ""}
                                                                                                                         :content-type :json
                                                                                                                         :form-params {:ResourceId ""
                                                                                                                                       :TagsList ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags"

	payload := strings.NewReader("{\n  \"ResourceId\": \"\",\n  \"TagsList\": \"\"\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

{
  "ResourceId": "",
  "TagsList": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ResourceId\": \"\",\n  \"TagsList\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ResourceId\": \"\",\n  \"TagsList\": \"\"\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  \"ResourceId\": \"\",\n  \"TagsList\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ResourceId\": \"\",\n  \"TagsList\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ResourceId: '',
  TagsList: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceId: '', TagsList: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceId":"","TagsList":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResourceId": "",\n  "TagsList": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ResourceId\": \"\",\n  \"TagsList\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags")
  .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({ResourceId: '', TagsList: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ResourceId: '', TagsList: ''},
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags');

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

req.type('json');
req.send({
  ResourceId: '',
  TagsList: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceId: '', TagsList: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceId":"","TagsList":""}'
};

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 = @{ @"ResourceId": @"",
                              @"TagsList": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags",
  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([
    'ResourceId' => '',
    'TagsList' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags', [
  'body' => '{
  "ResourceId": "",
  "TagsList": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'ResourceId' => '',
  'TagsList' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceId": "",
  "TagsList": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceId": "",
  "TagsList": ""
}'

import http.client

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

payload = "{\n  \"ResourceId\": \"\",\n  \"TagsList\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags"

payload = {
    "ResourceId": "",
    "TagsList": ""
}
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags"

payload <- "{\n  \"ResourceId\": \"\",\n  \"TagsList\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags")

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  \"ResourceId\": \"\",\n  \"TagsList\": \"\"\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  \"ResourceId\": \"\",\n  \"TagsList\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags";

    let payload = json!({
        "ResourceId": "",
        "TagsList": ""
    });

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceId": "",
  "TagsList": ""
}'

echo '{
  "ResourceId": "",
  "TagsList": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ResourceId": "",\n  "TagsList": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.AddTags")! 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 CancelQuery

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery

HEADERS

X-Amz-Target

BODY json

{
  "EventDataStore": "",
  "QueryId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery");

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  \"EventDataStore\": \"\",\n  \"QueryId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery" {:headers {:x-amz-target ""}
                                                                                                                             :content-type :json
                                                                                                                             :form-params {:EventDataStore ""
                                                                                                                                           :QueryId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery"

	payload := strings.NewReader("{\n  \"EventDataStore\": \"\",\n  \"QueryId\": \"\"\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: 43

{
  "EventDataStore": "",
  "QueryId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"EventDataStore\": \"\",\n  \"QueryId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"EventDataStore\": \"\",\n  \"QueryId\": \"\"\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  \"EventDataStore\": \"\",\n  \"QueryId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"EventDataStore\": \"\",\n  \"QueryId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  EventDataStore: '',
  QueryId: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {EventDataStore: '', QueryId: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EventDataStore":"","QueryId":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "EventDataStore": "",\n  "QueryId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"EventDataStore\": \"\",\n  \"QueryId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery")
  .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({EventDataStore: '', QueryId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {EventDataStore: '', QueryId: ''},
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery');

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

req.type('json');
req.send({
  EventDataStore: '',
  QueryId: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {EventDataStore: '', QueryId: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EventDataStore":"","QueryId":""}'
};

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 = @{ @"EventDataStore": @"",
                              @"QueryId": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery",
  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([
    'EventDataStore' => '',
    'QueryId' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery', [
  'body' => '{
  "EventDataStore": "",
  "QueryId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'EventDataStore' => '',
  'QueryId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EventDataStore": "",
  "QueryId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EventDataStore": "",
  "QueryId": ""
}'

import http.client

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

payload = "{\n  \"EventDataStore\": \"\",\n  \"QueryId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery"

payload = {
    "EventDataStore": "",
    "QueryId": ""
}
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery"

payload <- "{\n  \"EventDataStore\": \"\",\n  \"QueryId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery")

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  \"EventDataStore\": \"\",\n  \"QueryId\": \"\"\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  \"EventDataStore\": \"\",\n  \"QueryId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery";

    let payload = json!({
        "EventDataStore": "",
        "QueryId": ""
    });

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "EventDataStore": "",
  "QueryId": ""
}'

echo '{
  "EventDataStore": "",
  "QueryId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "EventDataStore": "",\n  "QueryId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CancelQuery")! 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 CreateChannel

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel

HEADERS

X-Amz-Target

BODY json

{
  "Name": "",
  "Source": "",
  "Destinations": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel");

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  \"Name\": \"\",\n  \"Source\": \"\",\n  \"Destinations\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel" {:headers {:x-amz-target ""}
                                                                                                                               :content-type :json
                                                                                                                               :form-params {:Name ""
                                                                                                                                             :Source ""
                                                                                                                                             :Destinations ""
                                                                                                                                             :Tags [{:Key ""
                                                                                                                                                     :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"Source\": \"\",\n  \"Destinations\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"Source\": \"\",\n  \"Destinations\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"Source\": \"\",\n  \"Destinations\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"Source\": \"\",\n  \"Destinations\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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: 118

{
  "Name": "",
  "Source": "",
  "Destinations": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"Source\": \"\",\n  \"Destinations\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"Source\": \"\",\n  \"Destinations\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Source\": \"\",\n  \"Destinations\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"Source\": \"\",\n  \"Destinations\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  Source: '',
  Destinations: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', Source: '', Destinations: '', Tags: [{Key: '', Value: ''}]}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","Source":"","Destinations":"","Tags":[{"Key":"","Value":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "Source": "",\n  "Destinations": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"Source\": \"\",\n  \"Destinations\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel")
  .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({Name: '', Source: '', Destinations: '', Tags: [{Key: '', Value: ''}]}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: '', Source: '', Destinations: '', Tags: [{Key: '', Value: ''}]},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel');

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

req.type('json');
req.send({
  Name: '',
  Source: '',
  Destinations: '',
  Tags: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: '', Source: '', Destinations: '', Tags: [{Key: '', Value: ''}]}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","Source":"","Destinations":"","Tags":[{"Key":"","Value":""}]}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"Source": @"",
                              @"Destinations": @"",
                              @"Tags": @[ @{ @"Key": @"", @"Value": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel"]
                                                       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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"Source\": \"\",\n  \"Destinations\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'Source' => '',
    'Destinations' => '',
    'Tags' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel', [
  'body' => '{
  "Name": "",
  "Source": "",
  "Destinations": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'Source' => '',
  'Destinations' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'Name' => '',
  'Source' => '',
  'Destinations' => '',
  'Tags' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Source": "",
  "Destinations": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "Source": "",
  "Destinations": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"Source\": \"\",\n  \"Destinations\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel"

payload = {
    "Name": "",
    "Source": "",
    "Destinations": "",
    "Tags": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel"

payload <- "{\n  \"Name\": \"\",\n  \"Source\": \"\",\n  \"Destinations\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel")

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  \"Name\": \"\",\n  \"Source\": \"\",\n  \"Destinations\": \"\",\n  \"Tags\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel";

    let payload = json!({
        "Name": "",
        "Source": "",
        "Destinations": "",
        "Tags": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": "",
  "Source": "",
  "Destinations": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

echo '{
  "Name": "",
  "Source": "",
  "Destinations": "",
  "Tags": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "Source": "",\n  "Destinations": "",\n  "Tags": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "Source": "",
  "Destinations": "",
  "Tags": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateChannel")! 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 CreateEventDataStore

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore

HEADERS

X-Amz-Target

BODY json

{
  "Name": "",
  "AdvancedEventSelectors": "",
  "MultiRegionEnabled": "",
  "OrganizationEnabled": "",
  "RetentionPeriod": "",
  "TerminationProtectionEnabled": "",
  "TagsList": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "KmsKeyId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore");

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  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"KmsKeyId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore" {:headers {:x-amz-target ""}
                                                                                                                                      :content-type :json
                                                                                                                                      :form-params {:Name ""
                                                                                                                                                    :AdvancedEventSelectors ""
                                                                                                                                                    :MultiRegionEnabled ""
                                                                                                                                                    :OrganizationEnabled ""
                                                                                                                                                    :RetentionPeriod ""
                                                                                                                                                    :TerminationProtectionEnabled ""
                                                                                                                                                    :TagsList [{:Key ""
                                                                                                                                                                :Value ""}]
                                                                                                                                                    :KmsKeyId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"KmsKeyId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"KmsKeyId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"KmsKeyId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"KmsKeyId\": \"\"\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: 254

{
  "Name": "",
  "AdvancedEventSelectors": "",
  "MultiRegionEnabled": "",
  "OrganizationEnabled": "",
  "RetentionPeriod": "",
  "TerminationProtectionEnabled": "",
  "TagsList": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "KmsKeyId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"KmsKeyId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"KmsKeyId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"KmsKeyId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"KmsKeyId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  AdvancedEventSelectors: '',
  MultiRegionEnabled: '',
  OrganizationEnabled: '',
  RetentionPeriod: '',
  TerminationProtectionEnabled: '',
  TagsList: [
    {
      Key: '',
      Value: ''
    }
  ],
  KmsKeyId: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    AdvancedEventSelectors: '',
    MultiRegionEnabled: '',
    OrganizationEnabled: '',
    RetentionPeriod: '',
    TerminationProtectionEnabled: '',
    TagsList: [{Key: '', Value: ''}],
    KmsKeyId: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","AdvancedEventSelectors":"","MultiRegionEnabled":"","OrganizationEnabled":"","RetentionPeriod":"","TerminationProtectionEnabled":"","TagsList":[{"Key":"","Value":""}],"KmsKeyId":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "AdvancedEventSelectors": "",\n  "MultiRegionEnabled": "",\n  "OrganizationEnabled": "",\n  "RetentionPeriod": "",\n  "TerminationProtectionEnabled": "",\n  "TagsList": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "KmsKeyId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"KmsKeyId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore")
  .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({
  Name: '',
  AdvancedEventSelectors: '',
  MultiRegionEnabled: '',
  OrganizationEnabled: '',
  RetentionPeriod: '',
  TerminationProtectionEnabled: '',
  TagsList: [{Key: '', Value: ''}],
  KmsKeyId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Name: '',
    AdvancedEventSelectors: '',
    MultiRegionEnabled: '',
    OrganizationEnabled: '',
    RetentionPeriod: '',
    TerminationProtectionEnabled: '',
    TagsList: [{Key: '', Value: ''}],
    KmsKeyId: ''
  },
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore');

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

req.type('json');
req.send({
  Name: '',
  AdvancedEventSelectors: '',
  MultiRegionEnabled: '',
  OrganizationEnabled: '',
  RetentionPeriod: '',
  TerminationProtectionEnabled: '',
  TagsList: [
    {
      Key: '',
      Value: ''
    }
  ],
  KmsKeyId: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    AdvancedEventSelectors: '',
    MultiRegionEnabled: '',
    OrganizationEnabled: '',
    RetentionPeriod: '',
    TerminationProtectionEnabled: '',
    TagsList: [{Key: '', Value: ''}],
    KmsKeyId: ''
  }
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","AdvancedEventSelectors":"","MultiRegionEnabled":"","OrganizationEnabled":"","RetentionPeriod":"","TerminationProtectionEnabled":"","TagsList":[{"Key":"","Value":""}],"KmsKeyId":""}'
};

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 = @{ @"Name": @"",
                              @"AdvancedEventSelectors": @"",
                              @"MultiRegionEnabled": @"",
                              @"OrganizationEnabled": @"",
                              @"RetentionPeriod": @"",
                              @"TerminationProtectionEnabled": @"",
                              @"TagsList": @[ @{ @"Key": @"", @"Value": @"" } ],
                              @"KmsKeyId": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore"]
                                                       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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"KmsKeyId\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'AdvancedEventSelectors' => '',
    'MultiRegionEnabled' => '',
    'OrganizationEnabled' => '',
    'RetentionPeriod' => '',
    'TerminationProtectionEnabled' => '',
    'TagsList' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ],
    'KmsKeyId' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore', [
  'body' => '{
  "Name": "",
  "AdvancedEventSelectors": "",
  "MultiRegionEnabled": "",
  "OrganizationEnabled": "",
  "RetentionPeriod": "",
  "TerminationProtectionEnabled": "",
  "TagsList": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "KmsKeyId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'AdvancedEventSelectors' => '',
  'MultiRegionEnabled' => '',
  'OrganizationEnabled' => '',
  'RetentionPeriod' => '',
  'TerminationProtectionEnabled' => '',
  'TagsList' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'KmsKeyId' => ''
]));

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

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

append(json_encode([
  'Name' => '',
  'AdvancedEventSelectors' => '',
  'MultiRegionEnabled' => '',
  'OrganizationEnabled' => '',
  'RetentionPeriod' => '',
  'TerminationProtectionEnabled' => '',
  'TagsList' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ],
  'KmsKeyId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "AdvancedEventSelectors": "",
  "MultiRegionEnabled": "",
  "OrganizationEnabled": "",
  "RetentionPeriod": "",
  "TerminationProtectionEnabled": "",
  "TagsList": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "KmsKeyId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "AdvancedEventSelectors": "",
  "MultiRegionEnabled": "",
  "OrganizationEnabled": "",
  "RetentionPeriod": "",
  "TerminationProtectionEnabled": "",
  "TagsList": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "KmsKeyId": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"KmsKeyId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore"

payload = {
    "Name": "",
    "AdvancedEventSelectors": "",
    "MultiRegionEnabled": "",
    "OrganizationEnabled": "",
    "RetentionPeriod": "",
    "TerminationProtectionEnabled": "",
    "TagsList": [
        {
            "Key": "",
            "Value": ""
        }
    ],
    "KmsKeyId": ""
}
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore"

payload <- "{\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"KmsKeyId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore")

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  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"KmsKeyId\": \"\"\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  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ],\n  \"KmsKeyId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore";

    let payload = json!({
        "Name": "",
        "AdvancedEventSelectors": "",
        "MultiRegionEnabled": "",
        "OrganizationEnabled": "",
        "RetentionPeriod": "",
        "TerminationProtectionEnabled": "",
        "TagsList": (
            json!({
                "Key": "",
                "Value": ""
            })
        ),
        "KmsKeyId": ""
    });

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": "",
  "AdvancedEventSelectors": "",
  "MultiRegionEnabled": "",
  "OrganizationEnabled": "",
  "RetentionPeriod": "",
  "TerminationProtectionEnabled": "",
  "TagsList": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "KmsKeyId": ""
}'

echo '{
  "Name": "",
  "AdvancedEventSelectors": "",
  "MultiRegionEnabled": "",
  "OrganizationEnabled": "",
  "RetentionPeriod": "",
  "TerminationProtectionEnabled": "",
  "TagsList": [
    {
      "Key": "",
      "Value": ""
    }
  ],
  "KmsKeyId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "AdvancedEventSelectors": "",\n  "MultiRegionEnabled": "",\n  "OrganizationEnabled": "",\n  "RetentionPeriod": "",\n  "TerminationProtectionEnabled": "",\n  "TagsList": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ],\n  "KmsKeyId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "AdvancedEventSelectors": "",
  "MultiRegionEnabled": "",
  "OrganizationEnabled": "",
  "RetentionPeriod": "",
  "TerminationProtectionEnabled": "",
  "TagsList": [
    [
      "Key": "",
      "Value": ""
    ]
  ],
  "KmsKeyId": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateEventDataStore")! 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 CreateTrail

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail

HEADERS

X-Amz-Target

BODY json

{
  "Name": "",
  "S3BucketName": "",
  "S3KeyPrefix": "",
  "SnsTopicName": "",
  "IncludeGlobalServiceEvents": "",
  "IsMultiRegionTrail": "",
  "EnableLogFileValidation": "",
  "CloudWatchLogsLogGroupArn": "",
  "CloudWatchLogsRoleArn": "",
  "KmsKeyId": "",
  "IsOrganizationTrail": "",
  "TagsList": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail");

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  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail" {:headers {:x-amz-target ""}
                                                                                                                             :content-type :json
                                                                                                                             :form-params {:Name ""
                                                                                                                                           :S3BucketName ""
                                                                                                                                           :S3KeyPrefix ""
                                                                                                                                           :SnsTopicName ""
                                                                                                                                           :IncludeGlobalServiceEvents ""
                                                                                                                                           :IsMultiRegionTrail ""
                                                                                                                                           :EnableLogFileValidation ""
                                                                                                                                           :CloudWatchLogsLogGroupArn ""
                                                                                                                                           :CloudWatchLogsRoleArn ""
                                                                                                                                           :KmsKeyId ""
                                                                                                                                           :IsOrganizationTrail ""
                                                                                                                                           :TagsList [{:Key ""
                                                                                                                                                       :Value ""}]}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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: 359

{
  "Name": "",
  "S3BucketName": "",
  "S3KeyPrefix": "",
  "SnsTopicName": "",
  "IncludeGlobalServiceEvents": "",
  "IsMultiRegionTrail": "",
  "EnableLogFileValidation": "",
  "CloudWatchLogsLogGroupArn": "",
  "CloudWatchLogsRoleArn": "",
  "KmsKeyId": "",
  "IsOrganizationTrail": "",
  "TagsList": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  S3BucketName: '',
  S3KeyPrefix: '',
  SnsTopicName: '',
  IncludeGlobalServiceEvents: '',
  IsMultiRegionTrail: '',
  EnableLogFileValidation: '',
  CloudWatchLogsLogGroupArn: '',
  CloudWatchLogsRoleArn: '',
  KmsKeyId: '',
  IsOrganizationTrail: '',
  TagsList: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    S3BucketName: '',
    S3KeyPrefix: '',
    SnsTopicName: '',
    IncludeGlobalServiceEvents: '',
    IsMultiRegionTrail: '',
    EnableLogFileValidation: '',
    CloudWatchLogsLogGroupArn: '',
    CloudWatchLogsRoleArn: '',
    KmsKeyId: '',
    IsOrganizationTrail: '',
    TagsList: [{Key: '', Value: ''}]
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","S3BucketName":"","S3KeyPrefix":"","SnsTopicName":"","IncludeGlobalServiceEvents":"","IsMultiRegionTrail":"","EnableLogFileValidation":"","CloudWatchLogsLogGroupArn":"","CloudWatchLogsRoleArn":"","KmsKeyId":"","IsOrganizationTrail":"","TagsList":[{"Key":"","Value":""}]}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "S3BucketName": "",\n  "S3KeyPrefix": "",\n  "SnsTopicName": "",\n  "IncludeGlobalServiceEvents": "",\n  "IsMultiRegionTrail": "",\n  "EnableLogFileValidation": "",\n  "CloudWatchLogsLogGroupArn": "",\n  "CloudWatchLogsRoleArn": "",\n  "KmsKeyId": "",\n  "IsOrganizationTrail": "",\n  "TagsList": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail")
  .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({
  Name: '',
  S3BucketName: '',
  S3KeyPrefix: '',
  SnsTopicName: '',
  IncludeGlobalServiceEvents: '',
  IsMultiRegionTrail: '',
  EnableLogFileValidation: '',
  CloudWatchLogsLogGroupArn: '',
  CloudWatchLogsRoleArn: '',
  KmsKeyId: '',
  IsOrganizationTrail: '',
  TagsList: [{Key: '', Value: ''}]
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Name: '',
    S3BucketName: '',
    S3KeyPrefix: '',
    SnsTopicName: '',
    IncludeGlobalServiceEvents: '',
    IsMultiRegionTrail: '',
    EnableLogFileValidation: '',
    CloudWatchLogsLogGroupArn: '',
    CloudWatchLogsRoleArn: '',
    KmsKeyId: '',
    IsOrganizationTrail: '',
    TagsList: [{Key: '', Value: ''}]
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail');

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

req.type('json');
req.send({
  Name: '',
  S3BucketName: '',
  S3KeyPrefix: '',
  SnsTopicName: '',
  IncludeGlobalServiceEvents: '',
  IsMultiRegionTrail: '',
  EnableLogFileValidation: '',
  CloudWatchLogsLogGroupArn: '',
  CloudWatchLogsRoleArn: '',
  KmsKeyId: '',
  IsOrganizationTrail: '',
  TagsList: [
    {
      Key: '',
      Value: ''
    }
  ]
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    S3BucketName: '',
    S3KeyPrefix: '',
    SnsTopicName: '',
    IncludeGlobalServiceEvents: '',
    IsMultiRegionTrail: '',
    EnableLogFileValidation: '',
    CloudWatchLogsLogGroupArn: '',
    CloudWatchLogsRoleArn: '',
    KmsKeyId: '',
    IsOrganizationTrail: '',
    TagsList: [{Key: '', Value: ''}]
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","S3BucketName":"","S3KeyPrefix":"","SnsTopicName":"","IncludeGlobalServiceEvents":"","IsMultiRegionTrail":"","EnableLogFileValidation":"","CloudWatchLogsLogGroupArn":"","CloudWatchLogsRoleArn":"","KmsKeyId":"","IsOrganizationTrail":"","TagsList":[{"Key":"","Value":""}]}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"Name": @"",
                              @"S3BucketName": @"",
                              @"S3KeyPrefix": @"",
                              @"SnsTopicName": @"",
                              @"IncludeGlobalServiceEvents": @"",
                              @"IsMultiRegionTrail": @"",
                              @"EnableLogFileValidation": @"",
                              @"CloudWatchLogsLogGroupArn": @"",
                              @"CloudWatchLogsRoleArn": @"",
                              @"KmsKeyId": @"",
                              @"IsOrganizationTrail": @"",
                              @"TagsList": @[ @{ @"Key": @"", @"Value": @"" } ] };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail"]
                                                       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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'S3BucketName' => '',
    'S3KeyPrefix' => '',
    'SnsTopicName' => '',
    'IncludeGlobalServiceEvents' => '',
    'IsMultiRegionTrail' => '',
    'EnableLogFileValidation' => '',
    'CloudWatchLogsLogGroupArn' => '',
    'CloudWatchLogsRoleArn' => '',
    'KmsKeyId' => '',
    'IsOrganizationTrail' => '',
    'TagsList' => [
        [
                'Key' => '',
                'Value' => ''
        ]
    ]
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail', [
  'body' => '{
  "Name": "",
  "S3BucketName": "",
  "S3KeyPrefix": "",
  "SnsTopicName": "",
  "IncludeGlobalServiceEvents": "",
  "IsMultiRegionTrail": "",
  "EnableLogFileValidation": "",
  "CloudWatchLogsLogGroupArn": "",
  "CloudWatchLogsRoleArn": "",
  "KmsKeyId": "",
  "IsOrganizationTrail": "",
  "TagsList": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'S3BucketName' => '',
  'S3KeyPrefix' => '',
  'SnsTopicName' => '',
  'IncludeGlobalServiceEvents' => '',
  'IsMultiRegionTrail' => '',
  'EnableLogFileValidation' => '',
  'CloudWatchLogsLogGroupArn' => '',
  'CloudWatchLogsRoleArn' => '',
  'KmsKeyId' => '',
  'IsOrganizationTrail' => '',
  'TagsList' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));

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

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

append(json_encode([
  'Name' => '',
  'S3BucketName' => '',
  'S3KeyPrefix' => '',
  'SnsTopicName' => '',
  'IncludeGlobalServiceEvents' => '',
  'IsMultiRegionTrail' => '',
  'EnableLogFileValidation' => '',
  'CloudWatchLogsLogGroupArn' => '',
  'CloudWatchLogsRoleArn' => '',
  'KmsKeyId' => '',
  'IsOrganizationTrail' => '',
  'TagsList' => [
    [
        'Key' => '',
        'Value' => ''
    ]
  ]
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "S3BucketName": "",
  "S3KeyPrefix": "",
  "SnsTopicName": "",
  "IncludeGlobalServiceEvents": "",
  "IsMultiRegionTrail": "",
  "EnableLogFileValidation": "",
  "CloudWatchLogsLogGroupArn": "",
  "CloudWatchLogsRoleArn": "",
  "KmsKeyId": "",
  "IsOrganizationTrail": "",
  "TagsList": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "S3BucketName": "",
  "S3KeyPrefix": "",
  "SnsTopicName": "",
  "IncludeGlobalServiceEvents": "",
  "IsMultiRegionTrail": "",
  "EnableLogFileValidation": "",
  "CloudWatchLogsLogGroupArn": "",
  "CloudWatchLogsRoleArn": "",
  "KmsKeyId": "",
  "IsOrganizationTrail": "",
  "TagsList": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail"

payload = {
    "Name": "",
    "S3BucketName": "",
    "S3KeyPrefix": "",
    "SnsTopicName": "",
    "IncludeGlobalServiceEvents": "",
    "IsMultiRegionTrail": "",
    "EnableLogFileValidation": "",
    "CloudWatchLogsLogGroupArn": "",
    "CloudWatchLogsRoleArn": "",
    "KmsKeyId": "",
    "IsOrganizationTrail": "",
    "TagsList": [
        {
            "Key": "",
            "Value": ""
        }
    ]
}
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail"

payload <- "{\n  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail")

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  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\",\n  \"TagsList\": [\n    {\n      \"Key\": \"\",\n      \"Value\": \"\"\n    }\n  ]\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail";

    let payload = json!({
        "Name": "",
        "S3BucketName": "",
        "S3KeyPrefix": "",
        "SnsTopicName": "",
        "IncludeGlobalServiceEvents": "",
        "IsMultiRegionTrail": "",
        "EnableLogFileValidation": "",
        "CloudWatchLogsLogGroupArn": "",
        "CloudWatchLogsRoleArn": "",
        "KmsKeyId": "",
        "IsOrganizationTrail": "",
        "TagsList": (
            json!({
                "Key": "",
                "Value": ""
            })
        )
    });

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": "",
  "S3BucketName": "",
  "S3KeyPrefix": "",
  "SnsTopicName": "",
  "IncludeGlobalServiceEvents": "",
  "IsMultiRegionTrail": "",
  "EnableLogFileValidation": "",
  "CloudWatchLogsLogGroupArn": "",
  "CloudWatchLogsRoleArn": "",
  "KmsKeyId": "",
  "IsOrganizationTrail": "",
  "TagsList": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}'

echo '{
  "Name": "",
  "S3BucketName": "",
  "S3KeyPrefix": "",
  "SnsTopicName": "",
  "IncludeGlobalServiceEvents": "",
  "IsMultiRegionTrail": "",
  "EnableLogFileValidation": "",
  "CloudWatchLogsLogGroupArn": "",
  "CloudWatchLogsRoleArn": "",
  "KmsKeyId": "",
  "IsOrganizationTrail": "",
  "TagsList": [
    {
      "Key": "",
      "Value": ""
    }
  ]
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "S3BucketName": "",\n  "S3KeyPrefix": "",\n  "SnsTopicName": "",\n  "IncludeGlobalServiceEvents": "",\n  "IsMultiRegionTrail": "",\n  "EnableLogFileValidation": "",\n  "CloudWatchLogsLogGroupArn": "",\n  "CloudWatchLogsRoleArn": "",\n  "KmsKeyId": "",\n  "IsOrganizationTrail": "",\n  "TagsList": [\n    {\n      "Key": "",\n      "Value": ""\n    }\n  ]\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "S3BucketName": "",
  "S3KeyPrefix": "",
  "SnsTopicName": "",
  "IncludeGlobalServiceEvents": "",
  "IsMultiRegionTrail": "",
  "EnableLogFileValidation": "",
  "CloudWatchLogsLogGroupArn": "",
  "CloudWatchLogsRoleArn": "",
  "KmsKeyId": "",
  "IsOrganizationTrail": "",
  "TagsList": [
    [
      "Key": "",
      "Value": ""
    ]
  ]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.CreateTrail")! 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 DeleteChannel

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel

HEADERS

X-Amz-Target

BODY json

{
  "Channel": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel" {:headers {:x-amz-target ""}
                                                                                                                               :content-type :json
                                                                                                                               :form-params {:Channel ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel"

	payload := strings.NewReader("{\n  \"Channel\": \"\"\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

{
  "Channel": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Channel\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Channel\": \"\"\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  \"Channel\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Channel\": \"\"\n}")
  .asString();

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

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Channel: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Channel":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Channel": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Channel\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel")
  .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({Channel: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Channel: ''},
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel');

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

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

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Channel: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Channel":""}'
};

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel",
  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([
    'Channel' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel', [
  'body' => '{
  "Channel": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'Channel' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Channel": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Channel": ""
}'

import http.client

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

payload = "{\n  \"Channel\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel"

payload = { "Channel": "" }
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel"

payload <- "{\n  \"Channel\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel")

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  \"Channel\": \"\"\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  \"Channel\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel";

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

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Channel": ""
}'

echo '{
  "Channel": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Channel": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteChannel")! 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 DeleteEventDataStore

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore

HEADERS

X-Amz-Target

BODY json

{
  "EventDataStore": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore" {:headers {:x-amz-target ""}
                                                                                                                                      :content-type :json
                                                                                                                                      :form-params {:EventDataStore ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore"

	payload := strings.NewReader("{\n  \"EventDataStore\": \"\"\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: 26

{
  "EventDataStore": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"EventDataStore\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"EventDataStore\": \"\"\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  \"EventDataStore\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"EventDataStore\": \"\"\n}")
  .asString();

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

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {EventDataStore: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EventDataStore":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "EventDataStore": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"EventDataStore\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore")
  .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({EventDataStore: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {EventDataStore: ''},
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore');

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

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

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {EventDataStore: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EventDataStore":""}'
};

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore",
  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([
    'EventDataStore' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore', [
  'body' => '{
  "EventDataStore": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'EventDataStore' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EventDataStore": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EventDataStore": ""
}'

import http.client

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

payload = "{\n  \"EventDataStore\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore"

payload = { "EventDataStore": "" }
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore"

payload <- "{\n  \"EventDataStore\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore")

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  \"EventDataStore\": \"\"\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  \"EventDataStore\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore";

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

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "EventDataStore": ""
}'

echo '{
  "EventDataStore": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "EventDataStore": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteEventDataStore")! 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 DeleteResourcePolicy

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy

HEADERS

X-Amz-Target

BODY json

{
  "ResourceArn": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy" {:headers {:x-amz-target ""}
                                                                                                                                      :content-type :json
                                                                                                                                      :form-params {:ResourceArn ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy"

	payload := strings.NewReader("{\n  \"ResourceArn\": \"\"\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: 23

{
  "ResourceArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ResourceArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ResourceArn\": \"\"\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}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ResourceArn\": \"\"\n}")
  .asString();

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

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResourceArn": ""\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}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy")
  .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: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ResourceArn: ''},
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy');

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

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

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":""}'
};

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy"]
                                                       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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy" 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}" in

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy",
  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' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy', [
  'body' => '{
  "ResourceArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'ResourceArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceArn": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceArn": ""
}'

import http.client

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

payload = "{\n  \"ResourceArn\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy"

payload = { "ResourceArn": "" }
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy"

payload <- "{\n  \"ResourceArn\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy")

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}"

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}"
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy";

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

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceArn": ""
}'

echo '{
  "ResourceArn": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy' \
  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}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteResourcePolicy")! 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 DeleteTrail

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail

HEADERS

X-Amz-Target

BODY json

{
  "Name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail" {:headers {:x-amz-target ""}
                                                                                                                             :content-type :json
                                                                                                                             :form-params {:Name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\"\n}"

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

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

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail"

	payload := strings.NewReader("{\n  \"Name\": \"\"\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: 16

{
  "Name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail")
  .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({Name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail');

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

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

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail', [
  'body' => '{
  "Name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'Name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail"

payload = { "Name": "" }
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail"

payload <- "{\n  \"Name\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail")

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  \"Name\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail";

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

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": ""
}'

echo '{
  "Name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeleteTrail")! 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 DeregisterOrganizationDelegatedAdmin

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin

HEADERS

X-Amz-Target

BODY json

{
  "DelegatedAdminAccountId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin" {:headers {:x-amz-target ""}
                                                                                                                                                      :content-type :json
                                                                                                                                                      :form-params {:DelegatedAdminAccountId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin"

	payload := strings.NewReader("{\n  \"DelegatedAdminAccountId\": \"\"\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: 35

{
  "DelegatedAdminAccountId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DelegatedAdminAccountId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DelegatedAdminAccountId\": \"\"\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  \"DelegatedAdminAccountId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"DelegatedAdminAccountId\": \"\"\n}")
  .asString();

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

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {DelegatedAdminAccountId: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DelegatedAdminAccountId":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DelegatedAdminAccountId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DelegatedAdminAccountId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin")
  .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({DelegatedAdminAccountId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {DelegatedAdminAccountId: ''},
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin');

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

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

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {DelegatedAdminAccountId: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DelegatedAdminAccountId":""}'
};

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin",
  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([
    'DelegatedAdminAccountId' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin', [
  'body' => '{
  "DelegatedAdminAccountId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'DelegatedAdminAccountId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DelegatedAdminAccountId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DelegatedAdminAccountId": ""
}'

import http.client

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

payload = "{\n  \"DelegatedAdminAccountId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin"

payload = { "DelegatedAdminAccountId": "" }
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin"

payload <- "{\n  \"DelegatedAdminAccountId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin")

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  \"DelegatedAdminAccountId\": \"\"\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  \"DelegatedAdminAccountId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin";

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

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "DelegatedAdminAccountId": ""
}'

echo '{
  "DelegatedAdminAccountId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "DelegatedAdminAccountId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DeregisterOrganizationDelegatedAdmin")! 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 DescribeQuery

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery

HEADERS

X-Amz-Target

BODY json

{
  "EventDataStore": "",
  "QueryId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery");

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  \"EventDataStore\": \"\",\n  \"QueryId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery" {:headers {:x-amz-target ""}
                                                                                                                               :content-type :json
                                                                                                                               :form-params {:EventDataStore ""
                                                                                                                                             :QueryId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery"

	payload := strings.NewReader("{\n  \"EventDataStore\": \"\",\n  \"QueryId\": \"\"\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: 43

{
  "EventDataStore": "",
  "QueryId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"EventDataStore\": \"\",\n  \"QueryId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"EventDataStore\": \"\",\n  \"QueryId\": \"\"\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  \"EventDataStore\": \"\",\n  \"QueryId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"EventDataStore\": \"\",\n  \"QueryId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  EventDataStore: '',
  QueryId: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {EventDataStore: '', QueryId: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EventDataStore":"","QueryId":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "EventDataStore": "",\n  "QueryId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"EventDataStore\": \"\",\n  \"QueryId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery")
  .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({EventDataStore: '', QueryId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {EventDataStore: '', QueryId: ''},
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery');

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

req.type('json');
req.send({
  EventDataStore: '',
  QueryId: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {EventDataStore: '', QueryId: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EventDataStore":"","QueryId":""}'
};

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 = @{ @"EventDataStore": @"",
                              @"QueryId": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery",
  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([
    'EventDataStore' => '',
    'QueryId' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery', [
  'body' => '{
  "EventDataStore": "",
  "QueryId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'EventDataStore' => '',
  'QueryId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EventDataStore": "",
  "QueryId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EventDataStore": "",
  "QueryId": ""
}'

import http.client

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

payload = "{\n  \"EventDataStore\": \"\",\n  \"QueryId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery"

payload = {
    "EventDataStore": "",
    "QueryId": ""
}
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery"

payload <- "{\n  \"EventDataStore\": \"\",\n  \"QueryId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery")

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  \"EventDataStore\": \"\",\n  \"QueryId\": \"\"\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  \"EventDataStore\": \"\",\n  \"QueryId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery";

    let payload = json!({
        "EventDataStore": "",
        "QueryId": ""
    });

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "EventDataStore": "",
  "QueryId": ""
}'

echo '{
  "EventDataStore": "",
  "QueryId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "EventDataStore": "",\n  "QueryId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeQuery")! 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 DescribeTrails

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails

HEADERS

X-Amz-Target

BODY json

{
  "trailNameList": "",
  "includeShadowTrails": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails");

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  \"trailNameList\": \"\",\n  \"includeShadowTrails\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails" {:headers {:x-amz-target ""}
                                                                                                                                :content-type :json
                                                                                                                                :form-params {:trailNameList ""
                                                                                                                                              :includeShadowTrails ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails"

	payload := strings.NewReader("{\n  \"trailNameList\": \"\",\n  \"includeShadowTrails\": \"\"\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

{
  "trailNameList": "",
  "includeShadowTrails": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"trailNameList\": \"\",\n  \"includeShadowTrails\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"trailNameList\": \"\",\n  \"includeShadowTrails\": \"\"\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  \"trailNameList\": \"\",\n  \"includeShadowTrails\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"trailNameList\": \"\",\n  \"includeShadowTrails\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  trailNameList: '',
  includeShadowTrails: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {trailNameList: '', includeShadowTrails: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"trailNameList":"","includeShadowTrails":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "trailNameList": "",\n  "includeShadowTrails": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"trailNameList\": \"\",\n  \"includeShadowTrails\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails")
  .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({trailNameList: '', includeShadowTrails: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {trailNameList: '', includeShadowTrails: ''},
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails');

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

req.type('json');
req.send({
  trailNameList: '',
  includeShadowTrails: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {trailNameList: '', includeShadowTrails: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"trailNameList":"","includeShadowTrails":""}'
};

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 = @{ @"trailNameList": @"",
                              @"includeShadowTrails": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails",
  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([
    'trailNameList' => '',
    'includeShadowTrails' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails', [
  'body' => '{
  "trailNameList": "",
  "includeShadowTrails": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'trailNameList' => '',
  'includeShadowTrails' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "trailNameList": "",
  "includeShadowTrails": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "trailNameList": "",
  "includeShadowTrails": ""
}'

import http.client

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

payload = "{\n  \"trailNameList\": \"\",\n  \"includeShadowTrails\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails"

payload = {
    "trailNameList": "",
    "includeShadowTrails": ""
}
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails"

payload <- "{\n  \"trailNameList\": \"\",\n  \"includeShadowTrails\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails")

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  \"trailNameList\": \"\",\n  \"includeShadowTrails\": \"\"\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  \"trailNameList\": \"\",\n  \"includeShadowTrails\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails";

    let payload = json!({
        "trailNameList": "",
        "includeShadowTrails": ""
    });

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "trailNameList": "",
  "includeShadowTrails": ""
}'

echo '{
  "trailNameList": "",
  "includeShadowTrails": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "trailNameList": "",\n  "includeShadowTrails": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.DescribeTrails")! 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 GetChannel

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel

HEADERS

X-Amz-Target

BODY json

{
  "Channel": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel" {:headers {:x-amz-target ""}
                                                                                                                            :content-type :json
                                                                                                                            :form-params {:Channel ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel"

	payload := strings.NewReader("{\n  \"Channel\": \"\"\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

{
  "Channel": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Channel\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Channel\": \"\"\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  \"Channel\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Channel\": \"\"\n}")
  .asString();

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

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Channel: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Channel":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Channel": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Channel\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel")
  .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({Channel: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Channel: ''},
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel');

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

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

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Channel: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Channel":""}'
};

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel",
  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([
    'Channel' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel', [
  'body' => '{
  "Channel": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'Channel' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Channel": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Channel": ""
}'

import http.client

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

payload = "{\n  \"Channel\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel"

payload = { "Channel": "" }
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel"

payload <- "{\n  \"Channel\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel")

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  \"Channel\": \"\"\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  \"Channel\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel";

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

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Channel": ""
}'

echo '{
  "Channel": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Channel": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetChannel")! 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 GetEventDataStore

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore

HEADERS

X-Amz-Target

BODY json

{
  "EventDataStore": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore" {:headers {:x-amz-target ""}
                                                                                                                                   :content-type :json
                                                                                                                                   :form-params {:EventDataStore ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore"

	payload := strings.NewReader("{\n  \"EventDataStore\": \"\"\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: 26

{
  "EventDataStore": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"EventDataStore\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"EventDataStore\": \"\"\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  \"EventDataStore\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"EventDataStore\": \"\"\n}")
  .asString();

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

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {EventDataStore: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EventDataStore":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "EventDataStore": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"EventDataStore\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore")
  .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({EventDataStore: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {EventDataStore: ''},
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore');

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

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

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {EventDataStore: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EventDataStore":""}'
};

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore",
  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([
    'EventDataStore' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore', [
  'body' => '{
  "EventDataStore": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'EventDataStore' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EventDataStore": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EventDataStore": ""
}'

import http.client

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

payload = "{\n  \"EventDataStore\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore"

payload = { "EventDataStore": "" }
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore"

payload <- "{\n  \"EventDataStore\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore")

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  \"EventDataStore\": \"\"\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  \"EventDataStore\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore";

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

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "EventDataStore": ""
}'

echo '{
  "EventDataStore": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "EventDataStore": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventDataStore")! 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 GetEventSelectors

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors

HEADERS

X-Amz-Target

BODY json

{
  "TrailName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors" {:headers {:x-amz-target ""}
                                                                                                                                   :content-type :json
                                                                                                                                   :form-params {:TrailName ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors"

	payload := strings.NewReader("{\n  \"TrailName\": \"\"\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

{
  "TrailName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TrailName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TrailName\": \"\"\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  \"TrailName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TrailName\": \"\"\n}")
  .asString();

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

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TrailName: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TrailName":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TrailName": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TrailName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors")
  .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({TrailName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {TrailName: ''},
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors');

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

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

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TrailName: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TrailName":""}'
};

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors",
  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([
    'TrailName' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors', [
  'body' => '{
  "TrailName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'TrailName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TrailName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TrailName": ""
}'

import http.client

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

payload = "{\n  \"TrailName\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors"

payload = { "TrailName": "" }
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors"

payload <- "{\n  \"TrailName\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors")

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  \"TrailName\": \"\"\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  \"TrailName\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors";

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

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "TrailName": ""
}'

echo '{
  "TrailName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TrailName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetEventSelectors")! 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 GetImport

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport

HEADERS

X-Amz-Target

BODY json

{
  "ImportId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport" {:headers {:x-amz-target ""}
                                                                                                                           :content-type :json
                                                                                                                           :form-params {:ImportId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport"

	payload := strings.NewReader("{\n  \"ImportId\": \"\"\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: 20

{
  "ImportId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ImportId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ImportId\": \"\"\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  \"ImportId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ImportId\": \"\"\n}")
  .asString();

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

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ImportId: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ImportId":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ImportId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ImportId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport")
  .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({ImportId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ImportId: ''},
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport');

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

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

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ImportId: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ImportId":""}'
};

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport",
  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([
    'ImportId' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport', [
  'body' => '{
  "ImportId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'ImportId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ImportId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ImportId": ""
}'

import http.client

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

payload = "{\n  \"ImportId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport"

payload = { "ImportId": "" }
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport"

payload <- "{\n  \"ImportId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport")

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  \"ImportId\": \"\"\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  \"ImportId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport";

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

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ImportId": ""
}'

echo '{
  "ImportId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ImportId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetImport")! 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 GetInsightSelectors

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors

HEADERS

X-Amz-Target

BODY json

{
  "TrailName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors" {:headers {:x-amz-target ""}
                                                                                                                                     :content-type :json
                                                                                                                                     :form-params {:TrailName ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors"

	payload := strings.NewReader("{\n  \"TrailName\": \"\"\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

{
  "TrailName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TrailName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TrailName\": \"\"\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  \"TrailName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TrailName\": \"\"\n}")
  .asString();

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

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TrailName: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TrailName":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TrailName": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TrailName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors")
  .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({TrailName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {TrailName: ''},
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors');

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

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

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TrailName: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TrailName":""}'
};

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors",
  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([
    'TrailName' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors', [
  'body' => '{
  "TrailName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'TrailName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TrailName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TrailName": ""
}'

import http.client

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

payload = "{\n  \"TrailName\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors"

payload = { "TrailName": "" }
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors"

payload <- "{\n  \"TrailName\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors")

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  \"TrailName\": \"\"\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  \"TrailName\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors";

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

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "TrailName": ""
}'

echo '{
  "TrailName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TrailName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetInsightSelectors")! 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 GetQueryResults

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults

HEADERS

X-Amz-Target

BODY json

{
  "EventDataStore": "",
  "QueryId": "",
  "NextToken": "",
  "MaxQueryResults": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults");

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  \"EventDataStore\": \"\",\n  \"QueryId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxQueryResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults" {:headers {:x-amz-target ""}
                                                                                                                                 :content-type :json
                                                                                                                                 :form-params {:EventDataStore ""
                                                                                                                                               :QueryId ""
                                                                                                                                               :NextToken ""
                                                                                                                                               :MaxQueryResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"EventDataStore\": \"\",\n  \"QueryId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxQueryResults\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"EventDataStore\": \"\",\n  \"QueryId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxQueryResults\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"EventDataStore\": \"\",\n  \"QueryId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxQueryResults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults"

	payload := strings.NewReader("{\n  \"EventDataStore\": \"\",\n  \"QueryId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxQueryResults\": \"\"\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: 87

{
  "EventDataStore": "",
  "QueryId": "",
  "NextToken": "",
  "MaxQueryResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"EventDataStore\": \"\",\n  \"QueryId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxQueryResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"EventDataStore\": \"\",\n  \"QueryId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxQueryResults\": \"\"\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  \"EventDataStore\": \"\",\n  \"QueryId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxQueryResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"EventDataStore\": \"\",\n  \"QueryId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxQueryResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  EventDataStore: '',
  QueryId: '',
  NextToken: '',
  MaxQueryResults: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {EventDataStore: '', QueryId: '', NextToken: '', MaxQueryResults: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EventDataStore":"","QueryId":"","NextToken":"","MaxQueryResults":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "EventDataStore": "",\n  "QueryId": "",\n  "NextToken": "",\n  "MaxQueryResults": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"EventDataStore\": \"\",\n  \"QueryId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxQueryResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults")
  .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({EventDataStore: '', QueryId: '', NextToken: '', MaxQueryResults: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {EventDataStore: '', QueryId: '', NextToken: '', MaxQueryResults: ''},
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults');

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

req.type('json');
req.send({
  EventDataStore: '',
  QueryId: '',
  NextToken: '',
  MaxQueryResults: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {EventDataStore: '', QueryId: '', NextToken: '', MaxQueryResults: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EventDataStore":"","QueryId":"","NextToken":"","MaxQueryResults":""}'
};

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 = @{ @"EventDataStore": @"",
                              @"QueryId": @"",
                              @"NextToken": @"",
                              @"MaxQueryResults": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults"]
                                                       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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"EventDataStore\": \"\",\n  \"QueryId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxQueryResults\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults",
  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([
    'EventDataStore' => '',
    'QueryId' => '',
    'NextToken' => '',
    'MaxQueryResults' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults', [
  'body' => '{
  "EventDataStore": "",
  "QueryId": "",
  "NextToken": "",
  "MaxQueryResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'EventDataStore' => '',
  'QueryId' => '',
  'NextToken' => '',
  'MaxQueryResults' => ''
]));

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

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

append(json_encode([
  'EventDataStore' => '',
  'QueryId' => '',
  'NextToken' => '',
  'MaxQueryResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EventDataStore": "",
  "QueryId": "",
  "NextToken": "",
  "MaxQueryResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EventDataStore": "",
  "QueryId": "",
  "NextToken": "",
  "MaxQueryResults": ""
}'

import http.client

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

payload = "{\n  \"EventDataStore\": \"\",\n  \"QueryId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxQueryResults\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults"

payload = {
    "EventDataStore": "",
    "QueryId": "",
    "NextToken": "",
    "MaxQueryResults": ""
}
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults"

payload <- "{\n  \"EventDataStore\": \"\",\n  \"QueryId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxQueryResults\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults")

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  \"EventDataStore\": \"\",\n  \"QueryId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxQueryResults\": \"\"\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  \"EventDataStore\": \"\",\n  \"QueryId\": \"\",\n  \"NextToken\": \"\",\n  \"MaxQueryResults\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults";

    let payload = json!({
        "EventDataStore": "",
        "QueryId": "",
        "NextToken": "",
        "MaxQueryResults": ""
    });

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "EventDataStore": "",
  "QueryId": "",
  "NextToken": "",
  "MaxQueryResults": ""
}'

echo '{
  "EventDataStore": "",
  "QueryId": "",
  "NextToken": "",
  "MaxQueryResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "EventDataStore": "",\n  "QueryId": "",\n  "NextToken": "",\n  "MaxQueryResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "EventDataStore": "",
  "QueryId": "",
  "NextToken": "",
  "MaxQueryResults": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetQueryResults")! 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 GetResourcePolicy

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy

HEADERS

X-Amz-Target

BODY json

{
  "ResourceArn": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy" {:headers {:x-amz-target ""}
                                                                                                                                   :content-type :json
                                                                                                                                   :form-params {:ResourceArn ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy"

	payload := strings.NewReader("{\n  \"ResourceArn\": \"\"\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: 23

{
  "ResourceArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ResourceArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ResourceArn\": \"\"\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}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ResourceArn\": \"\"\n}")
  .asString();

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

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResourceArn": ""\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}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy")
  .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: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ResourceArn: ''},
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy');

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

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

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":""}'
};

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy"]
                                                       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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy" 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}" in

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy",
  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' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy', [
  'body' => '{
  "ResourceArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'ResourceArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceArn": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceArn": ""
}'

import http.client

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

payload = "{\n  \"ResourceArn\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy"

payload = { "ResourceArn": "" }
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy"

payload <- "{\n  \"ResourceArn\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy")

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}"

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}"
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy";

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

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceArn": ""
}'

echo '{
  "ResourceArn": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy' \
  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}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetResourcePolicy")! 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 GetTrail

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail

HEADERS

X-Amz-Target

BODY json

{
  "Name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail" {:headers {:x-amz-target ""}
                                                                                                                          :content-type :json
                                                                                                                          :form-params {:Name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\"\n}"

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

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

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail"

	payload := strings.NewReader("{\n  \"Name\": \"\"\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: 16

{
  "Name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail")
  .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({Name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail');

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

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

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail', [
  'body' => '{
  "Name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'Name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail"

payload = { "Name": "" }
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail"

payload <- "{\n  \"Name\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail")

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  \"Name\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail";

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

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": ""
}'

echo '{
  "Name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrail")! 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 GetTrailStatus

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus

HEADERS

X-Amz-Target

BODY json

{
  "Name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus" {:headers {:x-amz-target ""}
                                                                                                                                :content-type :json
                                                                                                                                :form-params {:Name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\"\n}"

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

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

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus"

	payload := strings.NewReader("{\n  \"Name\": \"\"\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: 16

{
  "Name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus")
  .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({Name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus');

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

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

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus', [
  'body' => '{
  "Name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'Name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus"

payload = { "Name": "" }
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus"

payload <- "{\n  \"Name\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus")

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  \"Name\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus";

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

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": ""
}'

echo '{
  "Name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.GetTrailStatus")! 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 ListChannels

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels

HEADERS

X-Amz-Target

BODY json

{
  "MaxResults": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels");

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  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels" {:headers {:x-amz-target ""}
                                                                                                                              :content-type :json
                                                                                                                              :form-params {:MaxResults ""
                                                                                                                                            :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

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

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

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels"

	payload := strings.NewReader("{\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\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: 41

{
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  MaxResults: '',
  NextToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {MaxResults: '', NextToken: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"MaxResults":"","NextToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels")
  .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({MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {MaxResults: '', NextToken: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels');

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

req.type('json');
req.send({
  MaxResults: '',
  NextToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {MaxResults: '', NextToken: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"MaxResults":"","NextToken":""}'
};

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 = @{ @"MaxResults": @"",
                              @"NextToken": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels",
  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([
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels', [
  'body' => '{
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

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

payload = "{\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels"

payload = {
    "MaxResults": "",
    "NextToken": ""
}
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels"

payload <- "{\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels")

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  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels";

    let payload = json!({
        "MaxResults": "",
        "NextToken": ""
    });

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "MaxResults": "",
  "NextToken": ""
}'

echo '{
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListChannels")! 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 ListEventDataStores

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores

HEADERS

X-Amz-Target

BODY json

{
  "NextToken": "",
  "MaxResults": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores");

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  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores" {:headers {:x-amz-target ""}
                                                                                                                                     :content-type :json
                                                                                                                                     :form-params {:NextToken ""
                                                                                                                                                   :MaxResults ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores"

	payload := strings.NewReader("{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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: 41

{
  "NextToken": "",
  "MaxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  NextToken: '',
  MaxResults: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {NextToken: '', MaxResults: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"NextToken":"","MaxResults":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "NextToken": "",\n  "MaxResults": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores")
  .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({NextToken: '', MaxResults: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {NextToken: '', MaxResults: ''},
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores');

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

req.type('json');
req.send({
  NextToken: '',
  MaxResults: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {NextToken: '', MaxResults: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"NextToken":"","MaxResults":""}'
};

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 = @{ @"NextToken": @"",
                              @"MaxResults": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores",
  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([
    'NextToken' => '',
    'MaxResults' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores', [
  'body' => '{
  "NextToken": "",
  "MaxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'NextToken' => '',
  'MaxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "NextToken": "",
  "MaxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "NextToken": "",
  "MaxResults": ""
}'

import http.client

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

payload = "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores"

payload = {
    "NextToken": "",
    "MaxResults": ""
}
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores"

payload <- "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores")

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  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores";

    let payload = json!({
        "NextToken": "",
        "MaxResults": ""
    });

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "NextToken": "",
  "MaxResults": ""
}'

echo '{
  "NextToken": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "NextToken": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListEventDataStores")! 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 ListImportFailures

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures

HEADERS

X-Amz-Target

BODY json

{
  "ImportId": "",
  "MaxResults": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures");

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  \"ImportId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures" {:headers {:x-amz-target ""}
                                                                                                                                    :content-type :json
                                                                                                                                    :form-params {:ImportId ""
                                                                                                                                                  :MaxResults ""
                                                                                                                                                  :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ImportId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

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

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

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ImportId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures"

	payload := strings.NewReader("{\n  \"ImportId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\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

{
  "ImportId": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ImportId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ImportId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ImportId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ImportId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ImportId: '',
  MaxResults: '',
  NextToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ImportId: '', MaxResults: '', NextToken: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ImportId":"","MaxResults":"","NextToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ImportId": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ImportId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures")
  .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({ImportId: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ImportId: '', MaxResults: '', NextToken: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures');

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

req.type('json');
req.send({
  ImportId: '',
  MaxResults: '',
  NextToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ImportId: '', MaxResults: '', NextToken: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ImportId":"","MaxResults":"","NextToken":""}'
};

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 = @{ @"ImportId": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures"]
                                                       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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ImportId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures",
  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([
    'ImportId' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures', [
  'body' => '{
  "ImportId": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ImportId' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

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

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

append(json_encode([
  'ImportId' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ImportId": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ImportId": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

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

payload = "{\n  \"ImportId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures"

payload = {
    "ImportId": "",
    "MaxResults": "",
    "NextToken": ""
}
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures"

payload <- "{\n  \"ImportId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures")

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  \"ImportId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures";

    let payload = json!({
        "ImportId": "",
        "MaxResults": "",
        "NextToken": ""
    });

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ImportId": "",
  "MaxResults": "",
  "NextToken": ""
}'

echo '{
  "ImportId": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ImportId": "",\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImportFailures")! 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 ListImports

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports

HEADERS

X-Amz-Target

BODY json

{
  "MaxResults": "",
  "Destination": "",
  "ImportStatus": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports");

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  \"MaxResults\": \"\",\n  \"Destination\": \"\",\n  \"ImportStatus\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports" {:headers {:x-amz-target ""}
                                                                                                                             :content-type :json
                                                                                                                             :form-params {:MaxResults ""
                                                                                                                                           :Destination ""
                                                                                                                                           :ImportStatus ""
                                                                                                                                           :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"MaxResults\": \"\",\n  \"Destination\": \"\",\n  \"ImportStatus\": \"\",\n  \"NextToken\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"MaxResults\": \"\",\n  \"Destination\": \"\",\n  \"ImportStatus\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"MaxResults\": \"\",\n  \"Destination\": \"\",\n  \"ImportStatus\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports"

	payload := strings.NewReader("{\n  \"MaxResults\": \"\",\n  \"Destination\": \"\",\n  \"ImportStatus\": \"\",\n  \"NextToken\": \"\"\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: 84

{
  "MaxResults": "",
  "Destination": "",
  "ImportStatus": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"MaxResults\": \"\",\n  \"Destination\": \"\",\n  \"ImportStatus\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"MaxResults\": \"\",\n  \"Destination\": \"\",\n  \"ImportStatus\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"MaxResults\": \"\",\n  \"Destination\": \"\",\n  \"ImportStatus\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"MaxResults\": \"\",\n  \"Destination\": \"\",\n  \"ImportStatus\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  MaxResults: '',
  Destination: '',
  ImportStatus: '',
  NextToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {MaxResults: '', Destination: '', ImportStatus: '', NextToken: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"MaxResults":"","Destination":"","ImportStatus":"","NextToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "MaxResults": "",\n  "Destination": "",\n  "ImportStatus": "",\n  "NextToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"MaxResults\": \"\",\n  \"Destination\": \"\",\n  \"ImportStatus\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports")
  .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({MaxResults: '', Destination: '', ImportStatus: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {MaxResults: '', Destination: '', ImportStatus: '', NextToken: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports');

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

req.type('json');
req.send({
  MaxResults: '',
  Destination: '',
  ImportStatus: '',
  NextToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {MaxResults: '', Destination: '', ImportStatus: '', NextToken: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"MaxResults":"","Destination":"","ImportStatus":"","NextToken":""}'
};

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 = @{ @"MaxResults": @"",
                              @"Destination": @"",
                              @"ImportStatus": @"",
                              @"NextToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports"]
                                                       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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"MaxResults\": \"\",\n  \"Destination\": \"\",\n  \"ImportStatus\": \"\",\n  \"NextToken\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports",
  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([
    'MaxResults' => '',
    'Destination' => '',
    'ImportStatus' => '',
    'NextToken' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports', [
  'body' => '{
  "MaxResults": "",
  "Destination": "",
  "ImportStatus": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'MaxResults' => '',
  'Destination' => '',
  'ImportStatus' => '',
  'NextToken' => ''
]));

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

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

append(json_encode([
  'MaxResults' => '',
  'Destination' => '',
  'ImportStatus' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MaxResults": "",
  "Destination": "",
  "ImportStatus": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MaxResults": "",
  "Destination": "",
  "ImportStatus": "",
  "NextToken": ""
}'

import http.client

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

payload = "{\n  \"MaxResults\": \"\",\n  \"Destination\": \"\",\n  \"ImportStatus\": \"\",\n  \"NextToken\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports"

payload = {
    "MaxResults": "",
    "Destination": "",
    "ImportStatus": "",
    "NextToken": ""
}
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports"

payload <- "{\n  \"MaxResults\": \"\",\n  \"Destination\": \"\",\n  \"ImportStatus\": \"\",\n  \"NextToken\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports")

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  \"MaxResults\": \"\",\n  \"Destination\": \"\",\n  \"ImportStatus\": \"\",\n  \"NextToken\": \"\"\n}"

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports";

    let payload = json!({
        "MaxResults": "",
        "Destination": "",
        "ImportStatus": "",
        "NextToken": ""
    });

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "MaxResults": "",
  "Destination": "",
  "ImportStatus": "",
  "NextToken": ""
}'

echo '{
  "MaxResults": "",
  "Destination": "",
  "ImportStatus": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "MaxResults": "",\n  "Destination": "",\n  "ImportStatus": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "MaxResults": "",
  "Destination": "",
  "ImportStatus": "",
  "NextToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListImports")! 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 ListPublicKeys

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys

HEADERS

X-Amz-Target

BODY json

{
  "StartTime": "",
  "EndTime": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys");

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  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys" {:headers {:x-amz-target ""}
                                                                                                                                :content-type :json
                                                                                                                                :form-params {:StartTime ""
                                                                                                                                              :EndTime ""
                                                                                                                                              :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"NextToken\": \"\"\n}"

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

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

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys"

	payload := strings.NewReader("{\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"NextToken\": \"\"\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

{
  "StartTime": "",
  "EndTime": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  StartTime: '',
  EndTime: '',
  NextToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {StartTime: '', EndTime: '', NextToken: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"StartTime":"","EndTime":"","NextToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "StartTime": "",\n  "EndTime": "",\n  "NextToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys")
  .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({StartTime: '', EndTime: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {StartTime: '', EndTime: '', NextToken: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys');

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

req.type('json');
req.send({
  StartTime: '',
  EndTime: '',
  NextToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {StartTime: '', EndTime: '', NextToken: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"StartTime":"","EndTime":"","NextToken":""}'
};

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 = @{ @"StartTime": @"",
                              @"EndTime": @"",
                              @"NextToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys"]
                                                       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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"NextToken\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys",
  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([
    'StartTime' => '',
    'EndTime' => '',
    'NextToken' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys', [
  'body' => '{
  "StartTime": "",
  "EndTime": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'StartTime' => '',
  'EndTime' => '',
  'NextToken' => ''
]));

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

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

append(json_encode([
  'StartTime' => '',
  'EndTime' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StartTime": "",
  "EndTime": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "StartTime": "",
  "EndTime": "",
  "NextToken": ""
}'

import http.client

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

payload = "{\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"NextToken\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys"

payload = {
    "StartTime": "",
    "EndTime": "",
    "NextToken": ""
}
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys"

payload <- "{\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"NextToken\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys")

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  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"NextToken\": \"\"\n}"

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys";

    let payload = json!({
        "StartTime": "",
        "EndTime": "",
        "NextToken": ""
    });

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "StartTime": "",
  "EndTime": "",
  "NextToken": ""
}'

echo '{
  "StartTime": "",
  "EndTime": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "StartTime": "",\n  "EndTime": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListPublicKeys")! 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 ListQueries

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries

HEADERS

X-Amz-Target

BODY json

{
  "EventDataStore": "",
  "NextToken": "",
  "MaxResults": "",
  "StartTime": "",
  "EndTime": "",
  "QueryStatus": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries");

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  \"EventDataStore\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"QueryStatus\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries" {:headers {:x-amz-target ""}
                                                                                                                             :content-type :json
                                                                                                                             :form-params {:EventDataStore ""
                                                                                                                                           :NextToken ""
                                                                                                                                           :MaxResults ""
                                                                                                                                           :StartTime ""
                                                                                                                                           :EndTime ""
                                                                                                                                           :QueryStatus ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"EventDataStore\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"QueryStatus\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"EventDataStore\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"QueryStatus\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"EventDataStore\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"QueryStatus\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries"

	payload := strings.NewReader("{\n  \"EventDataStore\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"QueryStatus\": \"\"\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: 122

{
  "EventDataStore": "",
  "NextToken": "",
  "MaxResults": "",
  "StartTime": "",
  "EndTime": "",
  "QueryStatus": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"EventDataStore\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"QueryStatus\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"EventDataStore\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"QueryStatus\": \"\"\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  \"EventDataStore\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"QueryStatus\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"EventDataStore\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"QueryStatus\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  EventDataStore: '',
  NextToken: '',
  MaxResults: '',
  StartTime: '',
  EndTime: '',
  QueryStatus: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    EventDataStore: '',
    NextToken: '',
    MaxResults: '',
    StartTime: '',
    EndTime: '',
    QueryStatus: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EventDataStore":"","NextToken":"","MaxResults":"","StartTime":"","EndTime":"","QueryStatus":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "EventDataStore": "",\n  "NextToken": "",\n  "MaxResults": "",\n  "StartTime": "",\n  "EndTime": "",\n  "QueryStatus": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"EventDataStore\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"QueryStatus\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries")
  .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({
  EventDataStore: '',
  NextToken: '',
  MaxResults: '',
  StartTime: '',
  EndTime: '',
  QueryStatus: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    EventDataStore: '',
    NextToken: '',
    MaxResults: '',
    StartTime: '',
    EndTime: '',
    QueryStatus: ''
  },
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries');

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

req.type('json');
req.send({
  EventDataStore: '',
  NextToken: '',
  MaxResults: '',
  StartTime: '',
  EndTime: '',
  QueryStatus: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    EventDataStore: '',
    NextToken: '',
    MaxResults: '',
    StartTime: '',
    EndTime: '',
    QueryStatus: ''
  }
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EventDataStore":"","NextToken":"","MaxResults":"","StartTime":"","EndTime":"","QueryStatus":""}'
};

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 = @{ @"EventDataStore": @"",
                              @"NextToken": @"",
                              @"MaxResults": @"",
                              @"StartTime": @"",
                              @"EndTime": @"",
                              @"QueryStatus": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries"]
                                                       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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"EventDataStore\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"QueryStatus\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries",
  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([
    'EventDataStore' => '',
    'NextToken' => '',
    'MaxResults' => '',
    'StartTime' => '',
    'EndTime' => '',
    'QueryStatus' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries', [
  'body' => '{
  "EventDataStore": "",
  "NextToken": "",
  "MaxResults": "",
  "StartTime": "",
  "EndTime": "",
  "QueryStatus": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'EventDataStore' => '',
  'NextToken' => '',
  'MaxResults' => '',
  'StartTime' => '',
  'EndTime' => '',
  'QueryStatus' => ''
]));

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

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

append(json_encode([
  'EventDataStore' => '',
  'NextToken' => '',
  'MaxResults' => '',
  'StartTime' => '',
  'EndTime' => '',
  'QueryStatus' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EventDataStore": "",
  "NextToken": "",
  "MaxResults": "",
  "StartTime": "",
  "EndTime": "",
  "QueryStatus": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EventDataStore": "",
  "NextToken": "",
  "MaxResults": "",
  "StartTime": "",
  "EndTime": "",
  "QueryStatus": ""
}'

import http.client

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

payload = "{\n  \"EventDataStore\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"QueryStatus\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries"

payload = {
    "EventDataStore": "",
    "NextToken": "",
    "MaxResults": "",
    "StartTime": "",
    "EndTime": "",
    "QueryStatus": ""
}
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries"

payload <- "{\n  \"EventDataStore\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"QueryStatus\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries")

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  \"EventDataStore\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"QueryStatus\": \"\"\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  \"EventDataStore\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"QueryStatus\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries";

    let payload = json!({
        "EventDataStore": "",
        "NextToken": "",
        "MaxResults": "",
        "StartTime": "",
        "EndTime": "",
        "QueryStatus": ""
    });

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "EventDataStore": "",
  "NextToken": "",
  "MaxResults": "",
  "StartTime": "",
  "EndTime": "",
  "QueryStatus": ""
}'

echo '{
  "EventDataStore": "",
  "NextToken": "",
  "MaxResults": "",
  "StartTime": "",
  "EndTime": "",
  "QueryStatus": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "EventDataStore": "",\n  "NextToken": "",\n  "MaxResults": "",\n  "StartTime": "",\n  "EndTime": "",\n  "QueryStatus": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "EventDataStore": "",
  "NextToken": "",
  "MaxResults": "",
  "StartTime": "",
  "EndTime": "",
  "QueryStatus": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListQueries")! 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 ListTags

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags

HEADERS

X-Amz-Target

BODY json

{
  "ResourceIdList": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags");

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  \"ResourceIdList\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags" {:headers {:x-amz-target ""}
                                                                                                                          :content-type :json
                                                                                                                          :form-params {:ResourceIdList ""
                                                                                                                                        :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ResourceIdList\": \"\",\n  \"NextToken\": \"\"\n}"

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

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

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ResourceIdList\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags"

	payload := strings.NewReader("{\n  \"ResourceIdList\": \"\",\n  \"NextToken\": \"\"\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

{
  "ResourceIdList": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ResourceIdList\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ResourceIdList\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ResourceIdList\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ResourceIdList: '',
  NextToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceIdList: '', NextToken: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceIdList":"","NextToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResourceIdList": "",\n  "NextToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ResourceIdList\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags")
  .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({ResourceIdList: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ResourceIdList: '', NextToken: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags');

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

req.type('json');
req.send({
  ResourceIdList: '',
  NextToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceIdList: '', NextToken: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceIdList":"","NextToken":""}'
};

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 = @{ @"ResourceIdList": @"",
                              @"NextToken": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags",
  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([
    'ResourceIdList' => '',
    'NextToken' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags', [
  'body' => '{
  "ResourceIdList": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'ResourceIdList' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceIdList": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceIdList": "",
  "NextToken": ""
}'

import http.client

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

payload = "{\n  \"ResourceIdList\": \"\",\n  \"NextToken\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags"

payload = {
    "ResourceIdList": "",
    "NextToken": ""
}
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags"

payload <- "{\n  \"ResourceIdList\": \"\",\n  \"NextToken\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags")

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  \"ResourceIdList\": \"\",\n  \"NextToken\": \"\"\n}"

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags";

    let payload = json!({
        "ResourceIdList": "",
        "NextToken": ""
    });

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceIdList": "",
  "NextToken": ""
}'

echo '{
  "ResourceIdList": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ResourceIdList": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTags")! 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 ListTrails

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails

HEADERS

X-Amz-Target

BODY json

{
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails" {:headers {:x-amz-target ""}
                                                                                                                            :content-type :json
                                                                                                                            :form-params {:NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"NextToken\": \"\"\n}"

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

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

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails"

	payload := strings.NewReader("{\n  \"NextToken\": \"\"\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

{
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"NextToken\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {NextToken: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"NextToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "NextToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails")
  .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({NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {NextToken: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails');

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

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

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {NextToken: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"NextToken":""}'
};

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails",
  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([
    'NextToken' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails', [
  'body' => '{
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "NextToken": ""
}'

import http.client

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

payload = "{\n  \"NextToken\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails"

payload = { "NextToken": "" }
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails"

payload <- "{\n  \"NextToken\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails")

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  \"NextToken\": \"\"\n}"

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails";

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

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "NextToken": ""
}'

echo '{
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.ListTrails")! 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 LookupEvents

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents

HEADERS

X-Amz-Target

BODY json

{
  "LookupAttributes": "",
  "StartTime": "",
  "EndTime": "",
  "EventCategory": "",
  "MaxResults": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents");

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  \"LookupAttributes\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"EventCategory\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents" {:headers {:x-amz-target ""}
                                                                                                                              :content-type :json
                                                                                                                              :form-params {:LookupAttributes ""
                                                                                                                                            :StartTime ""
                                                                                                                                            :EndTime ""
                                                                                                                                            :EventCategory ""
                                                                                                                                            :MaxResults ""
                                                                                                                                            :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"LookupAttributes\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"EventCategory\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"LookupAttributes\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"EventCategory\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"LookupAttributes\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"EventCategory\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents"

	payload := strings.NewReader("{\n  \"LookupAttributes\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"EventCategory\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\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: 126

{
  "LookupAttributes": "",
  "StartTime": "",
  "EndTime": "",
  "EventCategory": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"LookupAttributes\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"EventCategory\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"LookupAttributes\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"EventCategory\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"LookupAttributes\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"EventCategory\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"LookupAttributes\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"EventCategory\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  LookupAttributes: '',
  StartTime: '',
  EndTime: '',
  EventCategory: '',
  MaxResults: '',
  NextToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    LookupAttributes: '',
    StartTime: '',
    EndTime: '',
    EventCategory: '',
    MaxResults: '',
    NextToken: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"LookupAttributes":"","StartTime":"","EndTime":"","EventCategory":"","MaxResults":"","NextToken":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "LookupAttributes": "",\n  "StartTime": "",\n  "EndTime": "",\n  "EventCategory": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"LookupAttributes\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"EventCategory\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents")
  .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({
  LookupAttributes: '',
  StartTime: '',
  EndTime: '',
  EventCategory: '',
  MaxResults: '',
  NextToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    LookupAttributes: '',
    StartTime: '',
    EndTime: '',
    EventCategory: '',
    MaxResults: '',
    NextToken: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents');

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

req.type('json');
req.send({
  LookupAttributes: '',
  StartTime: '',
  EndTime: '',
  EventCategory: '',
  MaxResults: '',
  NextToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    LookupAttributes: '',
    StartTime: '',
    EndTime: '',
    EventCategory: '',
    MaxResults: '',
    NextToken: ''
  }
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"LookupAttributes":"","StartTime":"","EndTime":"","EventCategory":"","MaxResults":"","NextToken":""}'
};

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 = @{ @"LookupAttributes": @"",
                              @"StartTime": @"",
                              @"EndTime": @"",
                              @"EventCategory": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents"]
                                                       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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"LookupAttributes\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"EventCategory\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents",
  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([
    'LookupAttributes' => '',
    'StartTime' => '',
    'EndTime' => '',
    'EventCategory' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents', [
  'body' => '{
  "LookupAttributes": "",
  "StartTime": "",
  "EndTime": "",
  "EventCategory": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'LookupAttributes' => '',
  'StartTime' => '',
  'EndTime' => '',
  'EventCategory' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

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

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

append(json_encode([
  'LookupAttributes' => '',
  'StartTime' => '',
  'EndTime' => '',
  'EventCategory' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "LookupAttributes": "",
  "StartTime": "",
  "EndTime": "",
  "EventCategory": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "LookupAttributes": "",
  "StartTime": "",
  "EndTime": "",
  "EventCategory": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

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

payload = "{\n  \"LookupAttributes\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"EventCategory\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents"

payload = {
    "LookupAttributes": "",
    "StartTime": "",
    "EndTime": "",
    "EventCategory": "",
    "MaxResults": "",
    "NextToken": ""
}
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents"

payload <- "{\n  \"LookupAttributes\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"EventCategory\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents")

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  \"LookupAttributes\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"EventCategory\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"LookupAttributes\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"EventCategory\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents";

    let payload = json!({
        "LookupAttributes": "",
        "StartTime": "",
        "EndTime": "",
        "EventCategory": "",
        "MaxResults": "",
        "NextToken": ""
    });

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "LookupAttributes": "",
  "StartTime": "",
  "EndTime": "",
  "EventCategory": "",
  "MaxResults": "",
  "NextToken": ""
}'

echo '{
  "LookupAttributes": "",
  "StartTime": "",
  "EndTime": "",
  "EventCategory": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "LookupAttributes": "",\n  "StartTime": "",\n  "EndTime": "",\n  "EventCategory": "",\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "LookupAttributes": "",
  "StartTime": "",
  "EndTime": "",
  "EventCategory": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.LookupEvents")! 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 PutEventSelectors

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors

HEADERS

X-Amz-Target

BODY json

{
  "TrailName": "",
  "EventSelectors": "",
  "AdvancedEventSelectors": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors");

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  \"TrailName\": \"\",\n  \"EventSelectors\": \"\",\n  \"AdvancedEventSelectors\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors" {:headers {:x-amz-target ""}
                                                                                                                                   :content-type :json
                                                                                                                                   :form-params {:TrailName ""
                                                                                                                                                 :EventSelectors ""
                                                                                                                                                 :AdvancedEventSelectors ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors"

	payload := strings.NewReader("{\n  \"TrailName\": \"\",\n  \"EventSelectors\": \"\",\n  \"AdvancedEventSelectors\": \"\"\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: 77

{
  "TrailName": "",
  "EventSelectors": "",
  "AdvancedEventSelectors": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TrailName\": \"\",\n  \"EventSelectors\": \"\",\n  \"AdvancedEventSelectors\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TrailName\": \"\",\n  \"EventSelectors\": \"\",\n  \"AdvancedEventSelectors\": \"\"\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  \"TrailName\": \"\",\n  \"EventSelectors\": \"\",\n  \"AdvancedEventSelectors\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TrailName\": \"\",\n  \"EventSelectors\": \"\",\n  \"AdvancedEventSelectors\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TrailName: '',
  EventSelectors: '',
  AdvancedEventSelectors: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TrailName: '', EventSelectors: '', AdvancedEventSelectors: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TrailName":"","EventSelectors":"","AdvancedEventSelectors":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TrailName": "",\n  "EventSelectors": "",\n  "AdvancedEventSelectors": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TrailName\": \"\",\n  \"EventSelectors\": \"\",\n  \"AdvancedEventSelectors\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors")
  .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({TrailName: '', EventSelectors: '', AdvancedEventSelectors: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {TrailName: '', EventSelectors: '', AdvancedEventSelectors: ''},
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors');

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

req.type('json');
req.send({
  TrailName: '',
  EventSelectors: '',
  AdvancedEventSelectors: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TrailName: '', EventSelectors: '', AdvancedEventSelectors: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TrailName":"","EventSelectors":"","AdvancedEventSelectors":""}'
};

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 = @{ @"TrailName": @"",
                              @"EventSelectors": @"",
                              @"AdvancedEventSelectors": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors"]
                                                       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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TrailName\": \"\",\n  \"EventSelectors\": \"\",\n  \"AdvancedEventSelectors\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors",
  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([
    'TrailName' => '',
    'EventSelectors' => '',
    'AdvancedEventSelectors' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors', [
  'body' => '{
  "TrailName": "",
  "EventSelectors": "",
  "AdvancedEventSelectors": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TrailName' => '',
  'EventSelectors' => '',
  'AdvancedEventSelectors' => ''
]));

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

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

append(json_encode([
  'TrailName' => '',
  'EventSelectors' => '',
  'AdvancedEventSelectors' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TrailName": "",
  "EventSelectors": "",
  "AdvancedEventSelectors": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TrailName": "",
  "EventSelectors": "",
  "AdvancedEventSelectors": ""
}'

import http.client

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

payload = "{\n  \"TrailName\": \"\",\n  \"EventSelectors\": \"\",\n  \"AdvancedEventSelectors\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors"

payload = {
    "TrailName": "",
    "EventSelectors": "",
    "AdvancedEventSelectors": ""
}
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors"

payload <- "{\n  \"TrailName\": \"\",\n  \"EventSelectors\": \"\",\n  \"AdvancedEventSelectors\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors")

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  \"TrailName\": \"\",\n  \"EventSelectors\": \"\",\n  \"AdvancedEventSelectors\": \"\"\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  \"TrailName\": \"\",\n  \"EventSelectors\": \"\",\n  \"AdvancedEventSelectors\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors";

    let payload = json!({
        "TrailName": "",
        "EventSelectors": "",
        "AdvancedEventSelectors": ""
    });

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "TrailName": "",
  "EventSelectors": "",
  "AdvancedEventSelectors": ""
}'

echo '{
  "TrailName": "",
  "EventSelectors": "",
  "AdvancedEventSelectors": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TrailName": "",\n  "EventSelectors": "",\n  "AdvancedEventSelectors": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutEventSelectors")! 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 PutInsightSelectors

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors

HEADERS

X-Amz-Target

BODY json

{
  "TrailName": "",
  "InsightSelectors": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors");

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  \"TrailName\": \"\",\n  \"InsightSelectors\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors" {:headers {:x-amz-target ""}
                                                                                                                                     :content-type :json
                                                                                                                                     :form-params {:TrailName ""
                                                                                                                                                   :InsightSelectors ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors"

	payload := strings.NewReader("{\n  \"TrailName\": \"\",\n  \"InsightSelectors\": \"\"\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: 47

{
  "TrailName": "",
  "InsightSelectors": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TrailName\": \"\",\n  \"InsightSelectors\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TrailName\": \"\",\n  \"InsightSelectors\": \"\"\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  \"TrailName\": \"\",\n  \"InsightSelectors\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TrailName\": \"\",\n  \"InsightSelectors\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TrailName: '',
  InsightSelectors: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TrailName: '', InsightSelectors: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TrailName":"","InsightSelectors":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TrailName": "",\n  "InsightSelectors": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TrailName\": \"\",\n  \"InsightSelectors\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors")
  .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({TrailName: '', InsightSelectors: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {TrailName: '', InsightSelectors: ''},
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors');

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

req.type('json');
req.send({
  TrailName: '',
  InsightSelectors: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TrailName: '', InsightSelectors: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TrailName":"","InsightSelectors":""}'
};

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 = @{ @"TrailName": @"",
                              @"InsightSelectors": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors",
  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([
    'TrailName' => '',
    'InsightSelectors' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors', [
  'body' => '{
  "TrailName": "",
  "InsightSelectors": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'TrailName' => '',
  'InsightSelectors' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TrailName": "",
  "InsightSelectors": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TrailName": "",
  "InsightSelectors": ""
}'

import http.client

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

payload = "{\n  \"TrailName\": \"\",\n  \"InsightSelectors\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors"

payload = {
    "TrailName": "",
    "InsightSelectors": ""
}
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors"

payload <- "{\n  \"TrailName\": \"\",\n  \"InsightSelectors\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors")

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  \"TrailName\": \"\",\n  \"InsightSelectors\": \"\"\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  \"TrailName\": \"\",\n  \"InsightSelectors\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors";

    let payload = json!({
        "TrailName": "",
        "InsightSelectors": ""
    });

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "TrailName": "",
  "InsightSelectors": ""
}'

echo '{
  "TrailName": "",
  "InsightSelectors": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TrailName": "",\n  "InsightSelectors": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutInsightSelectors")! 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 PutResourcePolicy

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy

HEADERS

X-Amz-Target

BODY json

{
  "ResourceArn": "",
  "ResourcePolicy": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy" {:headers {:x-amz-target ""}
                                                                                                                                   :content-type :json
                                                                                                                                   :form-params {:ResourceArn ""
                                                                                                                                                 :ResourcePolicy ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy"

	payload := strings.NewReader("{\n  \"ResourceArn\": \"\",\n  \"ResourcePolicy\": \"\"\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: 47

{
  "ResourceArn": "",
  "ResourcePolicy": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ResourceArn\": \"\",\n  \"ResourcePolicy\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ResourceArn\": \"\",\n  \"ResourcePolicy\": \"\"\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  \"ResourcePolicy\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ResourceArn\": \"\",\n  \"ResourcePolicy\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ResourceArn: '',
  ResourcePolicy: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: '', ResourcePolicy: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":"","ResourcePolicy":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResourceArn": "",\n  "ResourcePolicy": ""\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  \"ResourcePolicy\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy")
  .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: '', ResourcePolicy: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ResourceArn: '', ResourcePolicy: ''},
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy');

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

req.type('json');
req.send({
  ResourceArn: '',
  ResourcePolicy: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: '', ResourcePolicy: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":"","ResourcePolicy":""}'
};

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": @"",
                              @"ResourcePolicy": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy"]
                                                       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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy" 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  \"ResourcePolicy\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy",
  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' => '',
    'ResourcePolicy' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy', [
  'body' => '{
  "ResourceArn": "",
  "ResourcePolicy": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'ResourceArn' => '',
  'ResourcePolicy' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceArn": "",
  "ResourcePolicy": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceArn": "",
  "ResourcePolicy": ""
}'

import http.client

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

payload = "{\n  \"ResourceArn\": \"\",\n  \"ResourcePolicy\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy"

payload = {
    "ResourceArn": "",
    "ResourcePolicy": ""
}
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy"

payload <- "{\n  \"ResourceArn\": \"\",\n  \"ResourcePolicy\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy")

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  \"ResourcePolicy\": \"\"\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  \"ResourcePolicy\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy";

    let payload = json!({
        "ResourceArn": "",
        "ResourcePolicy": ""
    });

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceArn": "",
  "ResourcePolicy": ""
}'

echo '{
  "ResourceArn": "",
  "ResourcePolicy": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy' \
  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  "ResourcePolicy": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.PutResourcePolicy")! 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 RegisterOrganizationDelegatedAdmin

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin

HEADERS

X-Amz-Target

BODY json

{
  "MemberAccountId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin" {:headers {:x-amz-target ""}
                                                                                                                                                    :content-type :json
                                                                                                                                                    :form-params {:MemberAccountId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin"

	payload := strings.NewReader("{\n  \"MemberAccountId\": \"\"\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: 27

{
  "MemberAccountId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"MemberAccountId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"MemberAccountId\": \"\"\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  \"MemberAccountId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"MemberAccountId\": \"\"\n}")
  .asString();

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

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {MemberAccountId: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"MemberAccountId":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "MemberAccountId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"MemberAccountId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin")
  .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({MemberAccountId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {MemberAccountId: ''},
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin');

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

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

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {MemberAccountId: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"MemberAccountId":""}'
};

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin",
  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([
    'MemberAccountId' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin', [
  'body' => '{
  "MemberAccountId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'MemberAccountId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MemberAccountId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MemberAccountId": ""
}'

import http.client

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

payload = "{\n  \"MemberAccountId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin"

payload = { "MemberAccountId": "" }
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin"

payload <- "{\n  \"MemberAccountId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin")

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  \"MemberAccountId\": \"\"\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  \"MemberAccountId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin";

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

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "MemberAccountId": ""
}'

echo '{
  "MemberAccountId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "MemberAccountId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RegisterOrganizationDelegatedAdmin")! 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 RemoveTags

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags

HEADERS

X-Amz-Target

BODY json

{
  "ResourceId": "",
  "TagsList": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags");

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  \"ResourceId\": \"\",\n  \"TagsList\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags" {:headers {:x-amz-target ""}
                                                                                                                            :content-type :json
                                                                                                                            :form-params {:ResourceId ""
                                                                                                                                          :TagsList ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags"

	payload := strings.NewReader("{\n  \"ResourceId\": \"\",\n  \"TagsList\": \"\"\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

{
  "ResourceId": "",
  "TagsList": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ResourceId\": \"\",\n  \"TagsList\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ResourceId\": \"\",\n  \"TagsList\": \"\"\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  \"ResourceId\": \"\",\n  \"TagsList\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ResourceId\": \"\",\n  \"TagsList\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ResourceId: '',
  TagsList: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceId: '', TagsList: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceId":"","TagsList":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResourceId": "",\n  "TagsList": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ResourceId\": \"\",\n  \"TagsList\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags")
  .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({ResourceId: '', TagsList: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ResourceId: '', TagsList: ''},
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags');

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

req.type('json');
req.send({
  ResourceId: '',
  TagsList: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceId: '', TagsList: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceId":"","TagsList":""}'
};

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 = @{ @"ResourceId": @"",
                              @"TagsList": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags",
  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([
    'ResourceId' => '',
    'TagsList' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags', [
  'body' => '{
  "ResourceId": "",
  "TagsList": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'ResourceId' => '',
  'TagsList' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceId": "",
  "TagsList": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceId": "",
  "TagsList": ""
}'

import http.client

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

payload = "{\n  \"ResourceId\": \"\",\n  \"TagsList\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags"

payload = {
    "ResourceId": "",
    "TagsList": ""
}
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags"

payload <- "{\n  \"ResourceId\": \"\",\n  \"TagsList\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags")

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  \"ResourceId\": \"\",\n  \"TagsList\": \"\"\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  \"ResourceId\": \"\",\n  \"TagsList\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags";

    let payload = json!({
        "ResourceId": "",
        "TagsList": ""
    });

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceId": "",
  "TagsList": ""
}'

echo '{
  "ResourceId": "",
  "TagsList": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ResourceId": "",\n  "TagsList": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RemoveTags")! 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 RestoreEventDataStore

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore

HEADERS

X-Amz-Target

BODY json

{
  "EventDataStore": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore" {:headers {:x-amz-target ""}
                                                                                                                                       :content-type :json
                                                                                                                                       :form-params {:EventDataStore ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore"

	payload := strings.NewReader("{\n  \"EventDataStore\": \"\"\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: 26

{
  "EventDataStore": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"EventDataStore\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"EventDataStore\": \"\"\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  \"EventDataStore\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"EventDataStore\": \"\"\n}")
  .asString();

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

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {EventDataStore: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EventDataStore":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "EventDataStore": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"EventDataStore\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore")
  .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({EventDataStore: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {EventDataStore: ''},
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore');

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

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

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {EventDataStore: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EventDataStore":""}'
};

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore",
  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([
    'EventDataStore' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore', [
  'body' => '{
  "EventDataStore": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore');
$request->setMethod(HTTP_METH_POST);

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

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

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

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

append(json_encode([
  'EventDataStore' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EventDataStore": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EventDataStore": ""
}'

import http.client

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

payload = "{\n  \"EventDataStore\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore"

payload = { "EventDataStore": "" }
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore"

payload <- "{\n  \"EventDataStore\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore")

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  \"EventDataStore\": \"\"\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  \"EventDataStore\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore";

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

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "EventDataStore": ""
}'

echo '{
  "EventDataStore": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "EventDataStore": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.RestoreEventDataStore")! 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 StartImport

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport

HEADERS

X-Amz-Target

BODY json

{
  "Destinations": "",
  "ImportSource": "",
  "StartEventTime": "",
  "EndEventTime": "",
  "ImportId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport");

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  \"Destinations\": \"\",\n  \"ImportSource\": \"\",\n  \"StartEventTime\": \"\",\n  \"EndEventTime\": \"\",\n  \"ImportId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport" {:headers {:x-amz-target ""}
                                                                                                                             :content-type :json
                                                                                                                             :form-params {:Destinations ""
                                                                                                                                           :ImportSource ""
                                                                                                                                           :StartEventTime ""
                                                                                                                                           :EndEventTime ""
                                                                                                                                           :ImportId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Destinations\": \"\",\n  \"ImportSource\": \"\",\n  \"StartEventTime\": \"\",\n  \"EndEventTime\": \"\",\n  \"ImportId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Destinations\": \"\",\n  \"ImportSource\": \"\",\n  \"StartEventTime\": \"\",\n  \"EndEventTime\": \"\",\n  \"ImportId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Destinations\": \"\",\n  \"ImportSource\": \"\",\n  \"StartEventTime\": \"\",\n  \"EndEventTime\": \"\",\n  \"ImportId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport"

	payload := strings.NewReader("{\n  \"Destinations\": \"\",\n  \"ImportSource\": \"\",\n  \"StartEventTime\": \"\",\n  \"EndEventTime\": \"\",\n  \"ImportId\": \"\"\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: 110

{
  "Destinations": "",
  "ImportSource": "",
  "StartEventTime": "",
  "EndEventTime": "",
  "ImportId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Destinations\": \"\",\n  \"ImportSource\": \"\",\n  \"StartEventTime\": \"\",\n  \"EndEventTime\": \"\",\n  \"ImportId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Destinations\": \"\",\n  \"ImportSource\": \"\",\n  \"StartEventTime\": \"\",\n  \"EndEventTime\": \"\",\n  \"ImportId\": \"\"\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  \"Destinations\": \"\",\n  \"ImportSource\": \"\",\n  \"StartEventTime\": \"\",\n  \"EndEventTime\": \"\",\n  \"ImportId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Destinations\": \"\",\n  \"ImportSource\": \"\",\n  \"StartEventTime\": \"\",\n  \"EndEventTime\": \"\",\n  \"ImportId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Destinations: '',
  ImportSource: '',
  StartEventTime: '',
  EndEventTime: '',
  ImportId: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Destinations: '',
    ImportSource: '',
    StartEventTime: '',
    EndEventTime: '',
    ImportId: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Destinations":"","ImportSource":"","StartEventTime":"","EndEventTime":"","ImportId":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Destinations": "",\n  "ImportSource": "",\n  "StartEventTime": "",\n  "EndEventTime": "",\n  "ImportId": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Destinations\": \"\",\n  \"ImportSource\": \"\",\n  \"StartEventTime\": \"\",\n  \"EndEventTime\": \"\",\n  \"ImportId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport")
  .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({
  Destinations: '',
  ImportSource: '',
  StartEventTime: '',
  EndEventTime: '',
  ImportId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Destinations: '',
    ImportSource: '',
    StartEventTime: '',
    EndEventTime: '',
    ImportId: ''
  },
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport');

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

req.type('json');
req.send({
  Destinations: '',
  ImportSource: '',
  StartEventTime: '',
  EndEventTime: '',
  ImportId: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Destinations: '',
    ImportSource: '',
    StartEventTime: '',
    EndEventTime: '',
    ImportId: ''
  }
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Destinations":"","ImportSource":"","StartEventTime":"","EndEventTime":"","ImportId":""}'
};

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 = @{ @"Destinations": @"",
                              @"ImportSource": @"",
                              @"StartEventTime": @"",
                              @"EndEventTime": @"",
                              @"ImportId": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport"]
                                                       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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Destinations\": \"\",\n  \"ImportSource\": \"\",\n  \"StartEventTime\": \"\",\n  \"EndEventTime\": \"\",\n  \"ImportId\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport",
  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([
    'Destinations' => '',
    'ImportSource' => '',
    'StartEventTime' => '',
    'EndEventTime' => '',
    'ImportId' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport', [
  'body' => '{
  "Destinations": "",
  "ImportSource": "",
  "StartEventTime": "",
  "EndEventTime": "",
  "ImportId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport');
$request->setMethod(HTTP_METH_POST);

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Destinations' => '',
  'ImportSource' => '',
  'StartEventTime' => '',
  'EndEventTime' => '',
  'ImportId' => ''
]));

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

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

append(json_encode([
  'Destinations' => '',
  'ImportSource' => '',
  'StartEventTime' => '',
  'EndEventTime' => '',
  'ImportId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Destinations": "",
  "ImportSource": "",
  "StartEventTime": "",
  "EndEventTime": "",
  "ImportId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Destinations": "",
  "ImportSource": "",
  "StartEventTime": "",
  "EndEventTime": "",
  "ImportId": ""
}'

import http.client

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

payload = "{\n  \"Destinations\": \"\",\n  \"ImportSource\": \"\",\n  \"StartEventTime\": \"\",\n  \"EndEventTime\": \"\",\n  \"ImportId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport"

payload = {
    "Destinations": "",
    "ImportSource": "",
    "StartEventTime": "",
    "EndEventTime": "",
    "ImportId": ""
}
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport"

payload <- "{\n  \"Destinations\": \"\",\n  \"ImportSource\": \"\",\n  \"StartEventTime\": \"\",\n  \"EndEventTime\": \"\",\n  \"ImportId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport")

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  \"Destinations\": \"\",\n  \"ImportSource\": \"\",\n  \"StartEventTime\": \"\",\n  \"EndEventTime\": \"\",\n  \"ImportId\": \"\"\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  \"Destinations\": \"\",\n  \"ImportSource\": \"\",\n  \"StartEventTime\": \"\",\n  \"EndEventTime\": \"\",\n  \"ImportId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport";

    let payload = json!({
        "Destinations": "",
        "ImportSource": "",
        "StartEventTime": "",
        "EndEventTime": "",
        "ImportId": ""
    });

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Destinations": "",
  "ImportSource": "",
  "StartEventTime": "",
  "EndEventTime": "",
  "ImportId": ""
}'

echo '{
  "Destinations": "",
  "ImportSource": "",
  "StartEventTime": "",
  "EndEventTime": "",
  "ImportId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Destinations": "",\n  "ImportSource": "",\n  "StartEventTime": "",\n  "EndEventTime": "",\n  "ImportId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Destinations": "",
  "ImportSource": "",
  "StartEventTime": "",
  "EndEventTime": "",
  "ImportId": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartImport")! 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 StartLogging

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging

HEADERS

X-Amz-Target

BODY json

{
  "Name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging");

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging" {:headers {:x-amz-target ""}
                                                                                                                              :content-type :json
                                                                                                                              :form-params {:Name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\"\n}"

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

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

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging"

	payload := strings.NewReader("{\n  \"Name\": \"\"\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: 16

{
  "Name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\"\n}")
  .asString();

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

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging")
  .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({Name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging');

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

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

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging"]
                                                       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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging', [
  'body' => '{
  "Name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging"

payload = { "Name": "" }
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging"

payload <- "{\n  \"Name\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging")

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  \"Name\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging";

    let payload = json!({"Name": ""});

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": ""
}'

echo '{
  "Name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["Name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartLogging")! 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 StartQuery

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery

HEADERS

X-Amz-Target

BODY json

{
  "QueryStatement": "",
  "DeliveryS3Uri": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery");

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  \"QueryStatement\": \"\",\n  \"DeliveryS3Uri\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery" {:headers {:x-amz-target ""}
                                                                                                                            :content-type :json
                                                                                                                            :form-params {:QueryStatement ""
                                                                                                                                          :DeliveryS3Uri ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"QueryStatement\": \"\",\n  \"DeliveryS3Uri\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"QueryStatement\": \"\",\n  \"DeliveryS3Uri\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"QueryStatement\": \"\",\n  \"DeliveryS3Uri\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery"

	payload := strings.NewReader("{\n  \"QueryStatement\": \"\",\n  \"DeliveryS3Uri\": \"\"\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

{
  "QueryStatement": "",
  "DeliveryS3Uri": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"QueryStatement\": \"\",\n  \"DeliveryS3Uri\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"QueryStatement\": \"\",\n  \"DeliveryS3Uri\": \"\"\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  \"QueryStatement\": \"\",\n  \"DeliveryS3Uri\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"QueryStatement\": \"\",\n  \"DeliveryS3Uri\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  QueryStatement: '',
  DeliveryS3Uri: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {QueryStatement: '', DeliveryS3Uri: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"QueryStatement":"","DeliveryS3Uri":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "QueryStatement": "",\n  "DeliveryS3Uri": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"QueryStatement\": \"\",\n  \"DeliveryS3Uri\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery")
  .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({QueryStatement: '', DeliveryS3Uri: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {QueryStatement: '', DeliveryS3Uri: ''},
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  QueryStatement: '',
  DeliveryS3Uri: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {QueryStatement: '', DeliveryS3Uri: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"QueryStatement":"","DeliveryS3Uri":""}'
};

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 = @{ @"QueryStatement": @"",
                              @"DeliveryS3Uri": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery"]
                                                       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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"QueryStatement\": \"\",\n  \"DeliveryS3Uri\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery",
  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([
    'QueryStatement' => '',
    'DeliveryS3Uri' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery', [
  'body' => '{
  "QueryStatement": "",
  "DeliveryS3Uri": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'QueryStatement' => '',
  'DeliveryS3Uri' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'QueryStatement' => '',
  'DeliveryS3Uri' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QueryStatement": "",
  "DeliveryS3Uri": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "QueryStatement": "",
  "DeliveryS3Uri": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"QueryStatement\": \"\",\n  \"DeliveryS3Uri\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery"

payload = {
    "QueryStatement": "",
    "DeliveryS3Uri": ""
}
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery"

payload <- "{\n  \"QueryStatement\": \"\",\n  \"DeliveryS3Uri\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery")

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  \"QueryStatement\": \"\",\n  \"DeliveryS3Uri\": \"\"\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  \"QueryStatement\": \"\",\n  \"DeliveryS3Uri\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery";

    let payload = json!({
        "QueryStatement": "",
        "DeliveryS3Uri": ""
    });

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "QueryStatement": "",
  "DeliveryS3Uri": ""
}'

echo '{
  "QueryStatement": "",
  "DeliveryS3Uri": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "QueryStatement": "",\n  "DeliveryS3Uri": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "QueryStatement": "",
  "DeliveryS3Uri": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StartQuery")! 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 StopImport

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport

HEADERS

X-Amz-Target

BODY json

{
  "ImportId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport");

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  \"ImportId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport" {:headers {:x-amz-target ""}
                                                                                                                            :content-type :json
                                                                                                                            :form-params {:ImportId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ImportId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ImportId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ImportId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport"

	payload := strings.NewReader("{\n  \"ImportId\": \"\"\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: 20

{
  "ImportId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ImportId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ImportId\": \"\"\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  \"ImportId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ImportId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ImportId: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ImportId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ImportId":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ImportId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ImportId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport")
  .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({ImportId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ImportId: ''},
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ImportId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ImportId: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ImportId":""}'
};

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 = @{ @"ImportId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport"]
                                                       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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ImportId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport",
  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([
    'ImportId' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport', [
  'body' => '{
  "ImportId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ImportId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ImportId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ImportId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ImportId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ImportId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport"

payload = { "ImportId": "" }
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport"

payload <- "{\n  \"ImportId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport")

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  \"ImportId\": \"\"\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  \"ImportId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport";

    let payload = json!({"ImportId": ""});

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ImportId": ""
}'

echo '{
  "ImportId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ImportId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["ImportId": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopImport")! 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 StopLogging

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging

HEADERS

X-Amz-Target

BODY json

{
  "Name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging");

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  \"Name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging" {:headers {:x-amz-target ""}
                                                                                                                             :content-type :json
                                                                                                                             :form-params {:Name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging"

	payload := strings.NewReader("{\n  \"Name\": \"\"\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: 16

{
  "Name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging")
  .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({Name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Name: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":""}'
};

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 = @{ @"Name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging"]
                                                       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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging', [
  'body' => '{
  "Name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging"

payload = { "Name": "" }
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging"

payload <- "{\n  \"Name\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging")

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  \"Name\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Name\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging";

    let payload = json!({"Name": ""});

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": ""
}'

echo '{
  "Name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["Name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.StopLogging")! 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 UpdateChannel

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel

HEADERS

X-Amz-Target

BODY json

{
  "Channel": "",
  "Destinations": "",
  "Name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel");

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  \"Channel\": \"\",\n  \"Destinations\": \"\",\n  \"Name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel" {:headers {:x-amz-target ""}
                                                                                                                               :content-type :json
                                                                                                                               :form-params {:Channel ""
                                                                                                                                             :Destinations ""
                                                                                                                                             :Name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Channel\": \"\",\n  \"Destinations\": \"\",\n  \"Name\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Channel\": \"\",\n  \"Destinations\": \"\",\n  \"Name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Channel\": \"\",\n  \"Destinations\": \"\",\n  \"Name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel"

	payload := strings.NewReader("{\n  \"Channel\": \"\",\n  \"Destinations\": \"\",\n  \"Name\": \"\"\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: 55

{
  "Channel": "",
  "Destinations": "",
  "Name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Channel\": \"\",\n  \"Destinations\": \"\",\n  \"Name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Channel\": \"\",\n  \"Destinations\": \"\",\n  \"Name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Channel\": \"\",\n  \"Destinations\": \"\",\n  \"Name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Channel\": \"\",\n  \"Destinations\": \"\",\n  \"Name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Channel: '',
  Destinations: '',
  Name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Channel: '', Destinations: '', Name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Channel":"","Destinations":"","Name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Channel": "",\n  "Destinations": "",\n  "Name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Channel\": \"\",\n  \"Destinations\": \"\",\n  \"Name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel")
  .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({Channel: '', Destinations: '', Name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Channel: '', Destinations: '', Name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Channel: '',
  Destinations: '',
  Name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Channel: '', Destinations: '', Name: ''}
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Channel":"","Destinations":"","Name":""}'
};

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 = @{ @"Channel": @"",
                              @"Destinations": @"",
                              @"Name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel"]
                                                       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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Channel\": \"\",\n  \"Destinations\": \"\",\n  \"Name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel",
  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([
    'Channel' => '',
    'Destinations' => '',
    'Name' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel', [
  'body' => '{
  "Channel": "",
  "Destinations": "",
  "Name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Channel' => '',
  'Destinations' => '',
  'Name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Channel' => '',
  'Destinations' => '',
  'Name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Channel": "",
  "Destinations": "",
  "Name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Channel": "",
  "Destinations": "",
  "Name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Channel\": \"\",\n  \"Destinations\": \"\",\n  \"Name\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel"

payload = {
    "Channel": "",
    "Destinations": "",
    "Name": ""
}
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel"

payload <- "{\n  \"Channel\": \"\",\n  \"Destinations\": \"\",\n  \"Name\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel")

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  \"Channel\": \"\",\n  \"Destinations\": \"\",\n  \"Name\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"Channel\": \"\",\n  \"Destinations\": \"\",\n  \"Name\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel";

    let payload = json!({
        "Channel": "",
        "Destinations": "",
        "Name": ""
    });

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Channel": "",
  "Destinations": "",
  "Name": ""
}'

echo '{
  "Channel": "",
  "Destinations": "",
  "Name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Channel": "",\n  "Destinations": "",\n  "Name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Channel": "",
  "Destinations": "",
  "Name": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateChannel")! 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 UpdateEventDataStore

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore

HEADERS

X-Amz-Target

BODY json

{
  "EventDataStore": "",
  "Name": "",
  "AdvancedEventSelectors": "",
  "MultiRegionEnabled": "",
  "OrganizationEnabled": "",
  "RetentionPeriod": "",
  "TerminationProtectionEnabled": "",
  "KmsKeyId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore");

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  \"EventDataStore\": \"\",\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"KmsKeyId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore" {:headers {:x-amz-target ""}
                                                                                                                                      :content-type :json
                                                                                                                                      :form-params {:EventDataStore ""
                                                                                                                                                    :Name ""
                                                                                                                                                    :AdvancedEventSelectors ""
                                                                                                                                                    :MultiRegionEnabled ""
                                                                                                                                                    :OrganizationEnabled ""
                                                                                                                                                    :RetentionPeriod ""
                                                                                                                                                    :TerminationProtectionEnabled ""
                                                                                                                                                    :KmsKeyId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"EventDataStore\": \"\",\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"KmsKeyId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"EventDataStore\": \"\",\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"KmsKeyId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"EventDataStore\": \"\",\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"KmsKeyId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore"

	payload := strings.NewReader("{\n  \"EventDataStore\": \"\",\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"KmsKeyId\": \"\"\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: 210

{
  "EventDataStore": "",
  "Name": "",
  "AdvancedEventSelectors": "",
  "MultiRegionEnabled": "",
  "OrganizationEnabled": "",
  "RetentionPeriod": "",
  "TerminationProtectionEnabled": "",
  "KmsKeyId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"EventDataStore\": \"\",\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"KmsKeyId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"EventDataStore\": \"\",\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"KmsKeyId\": \"\"\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  \"EventDataStore\": \"\",\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"KmsKeyId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"EventDataStore\": \"\",\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"KmsKeyId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  EventDataStore: '',
  Name: '',
  AdvancedEventSelectors: '',
  MultiRegionEnabled: '',
  OrganizationEnabled: '',
  RetentionPeriod: '',
  TerminationProtectionEnabled: '',
  KmsKeyId: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    EventDataStore: '',
    Name: '',
    AdvancedEventSelectors: '',
    MultiRegionEnabled: '',
    OrganizationEnabled: '',
    RetentionPeriod: '',
    TerminationProtectionEnabled: '',
    KmsKeyId: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EventDataStore":"","Name":"","AdvancedEventSelectors":"","MultiRegionEnabled":"","OrganizationEnabled":"","RetentionPeriod":"","TerminationProtectionEnabled":"","KmsKeyId":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "EventDataStore": "",\n  "Name": "",\n  "AdvancedEventSelectors": "",\n  "MultiRegionEnabled": "",\n  "OrganizationEnabled": "",\n  "RetentionPeriod": "",\n  "TerminationProtectionEnabled": "",\n  "KmsKeyId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"EventDataStore\": \"\",\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"KmsKeyId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore")
  .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({
  EventDataStore: '',
  Name: '',
  AdvancedEventSelectors: '',
  MultiRegionEnabled: '',
  OrganizationEnabled: '',
  RetentionPeriod: '',
  TerminationProtectionEnabled: '',
  KmsKeyId: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    EventDataStore: '',
    Name: '',
    AdvancedEventSelectors: '',
    MultiRegionEnabled: '',
    OrganizationEnabled: '',
    RetentionPeriod: '',
    TerminationProtectionEnabled: '',
    KmsKeyId: ''
  },
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  EventDataStore: '',
  Name: '',
  AdvancedEventSelectors: '',
  MultiRegionEnabled: '',
  OrganizationEnabled: '',
  RetentionPeriod: '',
  TerminationProtectionEnabled: '',
  KmsKeyId: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    EventDataStore: '',
    Name: '',
    AdvancedEventSelectors: '',
    MultiRegionEnabled: '',
    OrganizationEnabled: '',
    RetentionPeriod: '',
    TerminationProtectionEnabled: '',
    KmsKeyId: ''
  }
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EventDataStore":"","Name":"","AdvancedEventSelectors":"","MultiRegionEnabled":"","OrganizationEnabled":"","RetentionPeriod":"","TerminationProtectionEnabled":"","KmsKeyId":""}'
};

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 = @{ @"EventDataStore": @"",
                              @"Name": @"",
                              @"AdvancedEventSelectors": @"",
                              @"MultiRegionEnabled": @"",
                              @"OrganizationEnabled": @"",
                              @"RetentionPeriod": @"",
                              @"TerminationProtectionEnabled": @"",
                              @"KmsKeyId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore"]
                                                       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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"EventDataStore\": \"\",\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"KmsKeyId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore",
  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([
    'EventDataStore' => '',
    'Name' => '',
    'AdvancedEventSelectors' => '',
    'MultiRegionEnabled' => '',
    'OrganizationEnabled' => '',
    'RetentionPeriod' => '',
    'TerminationProtectionEnabled' => '',
    'KmsKeyId' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore', [
  'body' => '{
  "EventDataStore": "",
  "Name": "",
  "AdvancedEventSelectors": "",
  "MultiRegionEnabled": "",
  "OrganizationEnabled": "",
  "RetentionPeriod": "",
  "TerminationProtectionEnabled": "",
  "KmsKeyId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'EventDataStore' => '',
  'Name' => '',
  'AdvancedEventSelectors' => '',
  'MultiRegionEnabled' => '',
  'OrganizationEnabled' => '',
  'RetentionPeriod' => '',
  'TerminationProtectionEnabled' => '',
  'KmsKeyId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'EventDataStore' => '',
  'Name' => '',
  'AdvancedEventSelectors' => '',
  'MultiRegionEnabled' => '',
  'OrganizationEnabled' => '',
  'RetentionPeriod' => '',
  'TerminationProtectionEnabled' => '',
  'KmsKeyId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EventDataStore": "",
  "Name": "",
  "AdvancedEventSelectors": "",
  "MultiRegionEnabled": "",
  "OrganizationEnabled": "",
  "RetentionPeriod": "",
  "TerminationProtectionEnabled": "",
  "KmsKeyId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EventDataStore": "",
  "Name": "",
  "AdvancedEventSelectors": "",
  "MultiRegionEnabled": "",
  "OrganizationEnabled": "",
  "RetentionPeriod": "",
  "TerminationProtectionEnabled": "",
  "KmsKeyId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"EventDataStore\": \"\",\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"KmsKeyId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore"

payload = {
    "EventDataStore": "",
    "Name": "",
    "AdvancedEventSelectors": "",
    "MultiRegionEnabled": "",
    "OrganizationEnabled": "",
    "RetentionPeriod": "",
    "TerminationProtectionEnabled": "",
    "KmsKeyId": ""
}
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore"

payload <- "{\n  \"EventDataStore\": \"\",\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"KmsKeyId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore")

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  \"EventDataStore\": \"\",\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"KmsKeyId\": \"\"\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  \"EventDataStore\": \"\",\n  \"Name\": \"\",\n  \"AdvancedEventSelectors\": \"\",\n  \"MultiRegionEnabled\": \"\",\n  \"OrganizationEnabled\": \"\",\n  \"RetentionPeriod\": \"\",\n  \"TerminationProtectionEnabled\": \"\",\n  \"KmsKeyId\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore";

    let payload = json!({
        "EventDataStore": "",
        "Name": "",
        "AdvancedEventSelectors": "",
        "MultiRegionEnabled": "",
        "OrganizationEnabled": "",
        "RetentionPeriod": "",
        "TerminationProtectionEnabled": "",
        "KmsKeyId": ""
    });

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "EventDataStore": "",
  "Name": "",
  "AdvancedEventSelectors": "",
  "MultiRegionEnabled": "",
  "OrganizationEnabled": "",
  "RetentionPeriod": "",
  "TerminationProtectionEnabled": "",
  "KmsKeyId": ""
}'

echo '{
  "EventDataStore": "",
  "Name": "",
  "AdvancedEventSelectors": "",
  "MultiRegionEnabled": "",
  "OrganizationEnabled": "",
  "RetentionPeriod": "",
  "TerminationProtectionEnabled": "",
  "KmsKeyId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "EventDataStore": "",\n  "Name": "",\n  "AdvancedEventSelectors": "",\n  "MultiRegionEnabled": "",\n  "OrganizationEnabled": "",\n  "RetentionPeriod": "",\n  "TerminationProtectionEnabled": "",\n  "KmsKeyId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "EventDataStore": "",
  "Name": "",
  "AdvancedEventSelectors": "",
  "MultiRegionEnabled": "",
  "OrganizationEnabled": "",
  "RetentionPeriod": "",
  "TerminationProtectionEnabled": "",
  "KmsKeyId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateEventDataStore")! 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 UpdateTrail

{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail

HEADERS

X-Amz-Target

BODY json

{
  "Name": "",
  "S3BucketName": "",
  "S3KeyPrefix": "",
  "SnsTopicName": "",
  "IncludeGlobalServiceEvents": "",
  "IsMultiRegionTrail": "",
  "EnableLogFileValidation": "",
  "CloudWatchLogsLogGroupArn": "",
  "CloudWatchLogsRoleArn": "",
  "KmsKeyId": "",
  "IsOrganizationTrail": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail");

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  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail" {:headers {:x-amz-target ""}
                                                                                                                             :content-type :json
                                                                                                                             :form-params {:Name ""
                                                                                                                                           :S3BucketName ""
                                                                                                                                           :S3KeyPrefix ""
                                                                                                                                           :SnsTopicName ""
                                                                                                                                           :IncludeGlobalServiceEvents ""
                                                                                                                                           :IsMultiRegionTrail ""
                                                                                                                                           :EnableLogFileValidation ""
                                                                                                                                           :CloudWatchLogsLogGroupArn ""
                                                                                                                                           :CloudWatchLogsRoleArn ""
                                                                                                                                           :KmsKeyId ""
                                                                                                                                           :IsOrganizationTrail ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\"\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: 291

{
  "Name": "",
  "S3BucketName": "",
  "S3KeyPrefix": "",
  "SnsTopicName": "",
  "IncludeGlobalServiceEvents": "",
  "IsMultiRegionTrail": "",
  "EnableLogFileValidation": "",
  "CloudWatchLogsLogGroupArn": "",
  "CloudWatchLogsRoleArn": "",
  "KmsKeyId": "",
  "IsOrganizationTrail": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail")
  .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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  S3BucketName: '',
  S3KeyPrefix: '',
  SnsTopicName: '',
  IncludeGlobalServiceEvents: '',
  IsMultiRegionTrail: '',
  EnableLogFileValidation: '',
  CloudWatchLogsLogGroupArn: '',
  CloudWatchLogsRoleArn: '',
  KmsKeyId: '',
  IsOrganizationTrail: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail');
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    S3BucketName: '',
    S3KeyPrefix: '',
    SnsTopicName: '',
    IncludeGlobalServiceEvents: '',
    IsMultiRegionTrail: '',
    EnableLogFileValidation: '',
    CloudWatchLogsLogGroupArn: '',
    CloudWatchLogsRoleArn: '',
    KmsKeyId: '',
    IsOrganizationTrail: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","S3BucketName":"","S3KeyPrefix":"","SnsTopicName":"","IncludeGlobalServiceEvents":"","IsMultiRegionTrail":"","EnableLogFileValidation":"","CloudWatchLogsLogGroupArn":"","CloudWatchLogsRoleArn":"","KmsKeyId":"","IsOrganizationTrail":""}'
};

try {
  const response = await 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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "S3BucketName": "",\n  "S3KeyPrefix": "",\n  "SnsTopicName": "",\n  "IncludeGlobalServiceEvents": "",\n  "IsMultiRegionTrail": "",\n  "EnableLogFileValidation": "",\n  "CloudWatchLogsLogGroupArn": "",\n  "CloudWatchLogsRoleArn": "",\n  "KmsKeyId": "",\n  "IsOrganizationTrail": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail")
  .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({
  Name: '',
  S3BucketName: '',
  S3KeyPrefix: '',
  SnsTopicName: '',
  IncludeGlobalServiceEvents: '',
  IsMultiRegionTrail: '',
  EnableLogFileValidation: '',
  CloudWatchLogsLogGroupArn: '',
  CloudWatchLogsRoleArn: '',
  KmsKeyId: '',
  IsOrganizationTrail: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Name: '',
    S3BucketName: '',
    S3KeyPrefix: '',
    SnsTopicName: '',
    IncludeGlobalServiceEvents: '',
    IsMultiRegionTrail: '',
    EnableLogFileValidation: '',
    CloudWatchLogsLogGroupArn: '',
    CloudWatchLogsRoleArn: '',
    KmsKeyId: '',
    IsOrganizationTrail: ''
  },
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  Name: '',
  S3BucketName: '',
  S3KeyPrefix: '',
  SnsTopicName: '',
  IncludeGlobalServiceEvents: '',
  IsMultiRegionTrail: '',
  EnableLogFileValidation: '',
  CloudWatchLogsLogGroupArn: '',
  CloudWatchLogsRoleArn: '',
  KmsKeyId: '',
  IsOrganizationTrail: ''
});

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    S3BucketName: '',
    S3KeyPrefix: '',
    SnsTopicName: '',
    IncludeGlobalServiceEvents: '',
    IsMultiRegionTrail: '',
    EnableLogFileValidation: '',
    CloudWatchLogsLogGroupArn: '',
    CloudWatchLogsRoleArn: '',
    KmsKeyId: '',
    IsOrganizationTrail: ''
  }
};

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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","S3BucketName":"","S3KeyPrefix":"","SnsTopicName":"","IncludeGlobalServiceEvents":"","IsMultiRegionTrail":"","EnableLogFileValidation":"","CloudWatchLogsLogGroupArn":"","CloudWatchLogsRoleArn":"","KmsKeyId":"","IsOrganizationTrail":""}'
};

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 = @{ @"Name": @"",
                              @"S3BucketName": @"",
                              @"S3KeyPrefix": @"",
                              @"SnsTopicName": @"",
                              @"IncludeGlobalServiceEvents": @"",
                              @"IsMultiRegionTrail": @"",
                              @"EnableLogFileValidation": @"",
                              @"CloudWatchLogsLogGroupArn": @"",
                              @"CloudWatchLogsRoleArn": @"",
                              @"KmsKeyId": @"",
                              @"IsOrganizationTrail": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail"]
                                                       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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'Name' => '',
    'S3BucketName' => '',
    'S3KeyPrefix' => '',
    'SnsTopicName' => '',
    'IncludeGlobalServiceEvents' => '',
    'IsMultiRegionTrail' => '',
    'EnableLogFileValidation' => '',
    'CloudWatchLogsLogGroupArn' => '',
    'CloudWatchLogsRoleArn' => '',
    'KmsKeyId' => '',
    'IsOrganizationTrail' => ''
  ]),
  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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail', [
  'body' => '{
  "Name": "",
  "S3BucketName": "",
  "S3KeyPrefix": "",
  "SnsTopicName": "",
  "IncludeGlobalServiceEvents": "",
  "IsMultiRegionTrail": "",
  "EnableLogFileValidation": "",
  "CloudWatchLogsLogGroupArn": "",
  "CloudWatchLogsRoleArn": "",
  "KmsKeyId": "",
  "IsOrganizationTrail": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'S3BucketName' => '',
  'S3KeyPrefix' => '',
  'SnsTopicName' => '',
  'IncludeGlobalServiceEvents' => '',
  'IsMultiRegionTrail' => '',
  'EnableLogFileValidation' => '',
  'CloudWatchLogsLogGroupArn' => '',
  'CloudWatchLogsRoleArn' => '',
  'KmsKeyId' => '',
  'IsOrganizationTrail' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'Name' => '',
  'S3BucketName' => '',
  'S3KeyPrefix' => '',
  'SnsTopicName' => '',
  'IncludeGlobalServiceEvents' => '',
  'IsMultiRegionTrail' => '',
  'EnableLogFileValidation' => '',
  'CloudWatchLogsLogGroupArn' => '',
  'CloudWatchLogsRoleArn' => '',
  'KmsKeyId' => '',
  'IsOrganizationTrail' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail');
$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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "S3BucketName": "",
  "S3KeyPrefix": "",
  "SnsTopicName": "",
  "IncludeGlobalServiceEvents": "",
  "IsMultiRegionTrail": "",
  "EnableLogFileValidation": "",
  "CloudWatchLogsLogGroupArn": "",
  "CloudWatchLogsRoleArn": "",
  "KmsKeyId": "",
  "IsOrganizationTrail": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "S3BucketName": "",
  "S3KeyPrefix": "",
  "SnsTopicName": "",
  "IncludeGlobalServiceEvents": "",
  "IsMultiRegionTrail": "",
  "EnableLogFileValidation": "",
  "CloudWatchLogsLogGroupArn": "",
  "CloudWatchLogsRoleArn": "",
  "KmsKeyId": "",
  "IsOrganizationTrail": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail"

payload = {
    "Name": "",
    "S3BucketName": "",
    "S3KeyPrefix": "",
    "SnsTopicName": "",
    "IncludeGlobalServiceEvents": "",
    "IsMultiRegionTrail": "",
    "EnableLogFileValidation": "",
    "CloudWatchLogsLogGroupArn": "",
    "CloudWatchLogsRoleArn": "",
    "KmsKeyId": "",
    "IsOrganizationTrail": ""
}
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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail"

payload <- "{\n  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail")

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  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\"\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  \"Name\": \"\",\n  \"S3BucketName\": \"\",\n  \"S3KeyPrefix\": \"\",\n  \"SnsTopicName\": \"\",\n  \"IncludeGlobalServiceEvents\": \"\",\n  \"IsMultiRegionTrail\": \"\",\n  \"EnableLogFileValidation\": \"\",\n  \"CloudWatchLogsLogGroupArn\": \"\",\n  \"CloudWatchLogsRoleArn\": \"\",\n  \"KmsKeyId\": \"\",\n  \"IsOrganizationTrail\": \"\"\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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail";

    let payload = json!({
        "Name": "",
        "S3BucketName": "",
        "S3KeyPrefix": "",
        "SnsTopicName": "",
        "IncludeGlobalServiceEvents": "",
        "IsMultiRegionTrail": "",
        "EnableLogFileValidation": "",
        "CloudWatchLogsLogGroupArn": "",
        "CloudWatchLogsRoleArn": "",
        "KmsKeyId": "",
        "IsOrganizationTrail": ""
    });

    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=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": "",
  "S3BucketName": "",
  "S3KeyPrefix": "",
  "SnsTopicName": "",
  "IncludeGlobalServiceEvents": "",
  "IsMultiRegionTrail": "",
  "EnableLogFileValidation": "",
  "CloudWatchLogsLogGroupArn": "",
  "CloudWatchLogsRoleArn": "",
  "KmsKeyId": "",
  "IsOrganizationTrail": ""
}'

echo '{
  "Name": "",
  "S3BucketName": "",
  "S3KeyPrefix": "",
  "SnsTopicName": "",
  "IncludeGlobalServiceEvents": "",
  "IsMultiRegionTrail": "",
  "EnableLogFileValidation": "",
  "CloudWatchLogsLogGroupArn": "",
  "CloudWatchLogsRoleArn": "",
  "KmsKeyId": "",
  "IsOrganizationTrail": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Name": "",\n  "S3BucketName": "",\n  "S3KeyPrefix": "",\n  "SnsTopicName": "",\n  "IncludeGlobalServiceEvents": "",\n  "IsMultiRegionTrail": "",\n  "EnableLogFileValidation": "",\n  "CloudWatchLogsLogGroupArn": "",\n  "CloudWatchLogsRoleArn": "",\n  "KmsKeyId": "",\n  "IsOrganizationTrail": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "S3BucketName": "",
  "S3KeyPrefix": "",
  "SnsTopicName": "",
  "IncludeGlobalServiceEvents": "",
  "IsMultiRegionTrail": "",
  "EnableLogFileValidation": "",
  "CloudWatchLogsLogGroupArn": "",
  "CloudWatchLogsRoleArn": "",
  "KmsKeyId": "",
  "IsOrganizationTrail": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=com.amazonaws.cloudtrail.v20131101.CloudTrail_20131101.UpdateTrail")! 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()

AWS CloudTrailv2013-11-01

Related APIs