AWS Cost Explorer Service

POST CreateAnomalyMonitor

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateAnomalyMonitor

HEADERS

X-Amz-Target

BODY json

{
  "AnomalyMonitor": "",
  "ResourceTags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateAnomalyMonitor" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:AnomalyMonitor ""
                                                                                                                     :ResourceTags ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateAnomalyMonitor"

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

{
  "AnomalyMonitor": "",
  "ResourceTags": ""
}

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

client.close();

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

const data = JSON.stringify({
  AnomalyMonitor: '',
  ResourceTags: ''
});

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=AWSInsightsIndexService.CreateAnomalyMonitor');
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=AWSInsightsIndexService.CreateAnomalyMonitor',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AnomalyMonitor: '', ResourceTags: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateAnomalyMonitor';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AnomalyMonitor":"","ResourceTags":""}'
};

try {
  const response = await 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=AWSInsightsIndexService.CreateAnomalyMonitor',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AnomalyMonitor": "",\n  "ResourceTags": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AnomalyMonitor\": \"\",\n  \"ResourceTags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateAnomalyMonitor")
  .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({AnomalyMonitor: '', ResourceTags: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  AnomalyMonitor: '',
  ResourceTags: ''
});

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=AWSInsightsIndexService.CreateAnomalyMonitor',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AnomalyMonitor: '', ResourceTags: ''}
};

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=AWSInsightsIndexService.CreateAnomalyMonitor';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AnomalyMonitor":"","ResourceTags":""}'
};

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateAnomalyMonitor",
  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([
    'AnomalyMonitor' => '',
    'ResourceTags' => ''
  ]),
  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=AWSInsightsIndexService.CreateAnomalyMonitor', [
  'body' => '{
  "AnomalyMonitor": "",
  "ResourceTags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'AnomalyMonitor' => '',
  'ResourceTags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateAnomalyMonitor');
$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=AWSInsightsIndexService.CreateAnomalyMonitor' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AnomalyMonitor": "",
  "ResourceTags": ""
}'

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

import http.client

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

payload = "{\n  \"AnomalyMonitor\": \"\",\n  \"ResourceTags\": \"\"\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=AWSInsightsIndexService.CreateAnomalyMonitor"

payload = {
    "AnomalyMonitor": "",
    "ResourceTags": ""
}
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=AWSInsightsIndexService.CreateAnomalyMonitor"

payload <- "{\n  \"AnomalyMonitor\": \"\",\n  \"ResourceTags\": \"\"\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=AWSInsightsIndexService.CreateAnomalyMonitor")

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  \"AnomalyMonitor\": \"\",\n  \"ResourceTags\": \"\"\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  \"AnomalyMonitor\": \"\",\n  \"ResourceTags\": \"\"\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=AWSInsightsIndexService.CreateAnomalyMonitor";

    let payload = json!({
        "AnomalyMonitor": "",
        "ResourceTags": ""
    });

    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=AWSInsightsIndexService.CreateAnomalyMonitor' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AnomalyMonitor": "",
  "ResourceTags": ""
}'

echo '{
  "AnomalyMonitor": "",
  "ResourceTags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateAnomalyMonitor' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateAnomalySubscription

HEADERS

X-Amz-Target

BODY json

{
  "AnomalySubscription": "",
  "ResourceTags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateAnomalySubscription" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:AnomalySubscription ""
                                                                                                                          :ResourceTags ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateAnomalySubscription"

	payload := strings.NewReader("{\n  \"AnomalySubscription\": \"\",\n  \"ResourceTags\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 53

{
  "AnomalySubscription": "",
  "ResourceTags": ""
}

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

client.close();

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

const data = JSON.stringify({
  AnomalySubscription: '',
  ResourceTags: ''
});

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=AWSInsightsIndexService.CreateAnomalySubscription');
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=AWSInsightsIndexService.CreateAnomalySubscription',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AnomalySubscription: '', ResourceTags: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateAnomalySubscription';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AnomalySubscription":"","ResourceTags":""}'
};

try {
  const response = await 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=AWSInsightsIndexService.CreateAnomalySubscription',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AnomalySubscription": "",\n  "ResourceTags": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AnomalySubscription\": \"\",\n  \"ResourceTags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateAnomalySubscription")
  .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({AnomalySubscription: '', ResourceTags: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  AnomalySubscription: '',
  ResourceTags: ''
});

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=AWSInsightsIndexService.CreateAnomalySubscription',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AnomalySubscription: '', ResourceTags: ''}
};

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=AWSInsightsIndexService.CreateAnomalySubscription';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AnomalySubscription":"","ResourceTags":""}'
};

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateAnomalySubscription",
  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([
    'AnomalySubscription' => '',
    'ResourceTags' => ''
  ]),
  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=AWSInsightsIndexService.CreateAnomalySubscription', [
  'body' => '{
  "AnomalySubscription": "",
  "ResourceTags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'AnomalySubscription' => '',
  'ResourceTags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateAnomalySubscription');
$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=AWSInsightsIndexService.CreateAnomalySubscription' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AnomalySubscription": "",
  "ResourceTags": ""
}'

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

import http.client

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

payload = "{\n  \"AnomalySubscription\": \"\",\n  \"ResourceTags\": \"\"\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=AWSInsightsIndexService.CreateAnomalySubscription"

payload = {
    "AnomalySubscription": "",
    "ResourceTags": ""
}
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=AWSInsightsIndexService.CreateAnomalySubscription"

payload <- "{\n  \"AnomalySubscription\": \"\",\n  \"ResourceTags\": \"\"\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=AWSInsightsIndexService.CreateAnomalySubscription")

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  \"AnomalySubscription\": \"\",\n  \"ResourceTags\": \"\"\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  \"AnomalySubscription\": \"\",\n  \"ResourceTags\": \"\"\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=AWSInsightsIndexService.CreateAnomalySubscription";

    let payload = json!({
        "AnomalySubscription": "",
        "ResourceTags": ""
    });

    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=AWSInsightsIndexService.CreateAnomalySubscription' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AnomalySubscription": "",
  "ResourceTags": ""
}'

echo '{
  "AnomalySubscription": "",
  "ResourceTags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateAnomalySubscription' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateCostCategoryDefinition

HEADERS

X-Amz-Target

BODY json

{
  "Name": "",
  "EffectiveStart": "",
  "RuleVersion": "",
  "Rules": "",
  "DefaultValue": "",
  "SplitChargeRules": "",
  "ResourceTags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"EffectiveStart\": \"\",\n  \"RuleVersion\": \"\",\n  \"Rules\": \"\",\n  \"DefaultValue\": \"\",\n  \"SplitChargeRules\": \"\",\n  \"ResourceTags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateCostCategoryDefinition" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:Name ""
                                                                                                                             :EffectiveStart ""
                                                                                                                             :RuleVersion ""
                                                                                                                             :Rules ""
                                                                                                                             :DefaultValue ""
                                                                                                                             :SplitChargeRules ""
                                                                                                                             :ResourceTags ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateCostCategoryDefinition"

	payload := strings.NewReader("{\n  \"Name\": \"\",\n  \"EffectiveStart\": \"\",\n  \"RuleVersion\": \"\",\n  \"Rules\": \"\",\n  \"DefaultValue\": \"\",\n  \"SplitChargeRules\": \"\",\n  \"ResourceTags\": \"\"\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: 146

{
  "Name": "",
  "EffectiveStart": "",
  "RuleVersion": "",
  "Rules": "",
  "DefaultValue": "",
  "SplitChargeRules": "",
  "ResourceTags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateCostCategoryDefinition")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Name\": \"\",\n  \"EffectiveStart\": \"\",\n  \"RuleVersion\": \"\",\n  \"Rules\": \"\",\n  \"DefaultValue\": \"\",\n  \"SplitChargeRules\": \"\",\n  \"ResourceTags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateCostCategoryDefinition"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Name\": \"\",\n  \"EffectiveStart\": \"\",\n  \"RuleVersion\": \"\",\n  \"Rules\": \"\",\n  \"DefaultValue\": \"\",\n  \"SplitChargeRules\": \"\",\n  \"ResourceTags\": \"\"\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  \"EffectiveStart\": \"\",\n  \"RuleVersion\": \"\",\n  \"Rules\": \"\",\n  \"DefaultValue\": \"\",\n  \"SplitChargeRules\": \"\",\n  \"ResourceTags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateCostCategoryDefinition")
  .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=AWSInsightsIndexService.CreateCostCategoryDefinition")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Name\": \"\",\n  \"EffectiveStart\": \"\",\n  \"RuleVersion\": \"\",\n  \"Rules\": \"\",\n  \"DefaultValue\": \"\",\n  \"SplitChargeRules\": \"\",\n  \"ResourceTags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Name: '',
  EffectiveStart: '',
  RuleVersion: '',
  Rules: '',
  DefaultValue: '',
  SplitChargeRules: '',
  ResourceTags: ''
});

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=AWSInsightsIndexService.CreateCostCategoryDefinition');
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=AWSInsightsIndexService.CreateCostCategoryDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    EffectiveStart: '',
    RuleVersion: '',
    Rules: '',
    DefaultValue: '',
    SplitChargeRules: '',
    ResourceTags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateCostCategoryDefinition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","EffectiveStart":"","RuleVersion":"","Rules":"","DefaultValue":"","SplitChargeRules":"","ResourceTags":""}'
};

try {
  const response = await 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=AWSInsightsIndexService.CreateCostCategoryDefinition',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Name": "",\n  "EffectiveStart": "",\n  "RuleVersion": "",\n  "Rules": "",\n  "DefaultValue": "",\n  "SplitChargeRules": "",\n  "ResourceTags": ""\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  \"EffectiveStart\": \"\",\n  \"RuleVersion\": \"\",\n  \"Rules\": \"\",\n  \"DefaultValue\": \"\",\n  \"SplitChargeRules\": \"\",\n  \"ResourceTags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateCostCategoryDefinition")
  .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: '',
  EffectiveStart: '',
  RuleVersion: '',
  Rules: '',
  DefaultValue: '',
  SplitChargeRules: '',
  ResourceTags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateCostCategoryDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Name: '',
    EffectiveStart: '',
    RuleVersion: '',
    Rules: '',
    DefaultValue: '',
    SplitChargeRules: '',
    ResourceTags: ''
  },
  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=AWSInsightsIndexService.CreateCostCategoryDefinition');

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

req.type('json');
req.send({
  Name: '',
  EffectiveStart: '',
  RuleVersion: '',
  Rules: '',
  DefaultValue: '',
  SplitChargeRules: '',
  ResourceTags: ''
});

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=AWSInsightsIndexService.CreateCostCategoryDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Name: '',
    EffectiveStart: '',
    RuleVersion: '',
    Rules: '',
    DefaultValue: '',
    SplitChargeRules: '',
    ResourceTags: ''
  }
};

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=AWSInsightsIndexService.CreateCostCategoryDefinition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Name":"","EffectiveStart":"","RuleVersion":"","Rules":"","DefaultValue":"","SplitChargeRules":"","ResourceTags":""}'
};

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": @"",
                              @"EffectiveStart": @"",
                              @"RuleVersion": @"",
                              @"Rules": @"",
                              @"DefaultValue": @"",
                              @"SplitChargeRules": @"",
                              @"ResourceTags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateCostCategoryDefinition"]
                                                       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=AWSInsightsIndexService.CreateCostCategoryDefinition" 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  \"EffectiveStart\": \"\",\n  \"RuleVersion\": \"\",\n  \"Rules\": \"\",\n  \"DefaultValue\": \"\",\n  \"SplitChargeRules\": \"\",\n  \"ResourceTags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateCostCategoryDefinition",
  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' => '',
    'EffectiveStart' => '',
    'RuleVersion' => '',
    'Rules' => '',
    'DefaultValue' => '',
    'SplitChargeRules' => '',
    'ResourceTags' => ''
  ]),
  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=AWSInsightsIndexService.CreateCostCategoryDefinition', [
  'body' => '{
  "Name": "",
  "EffectiveStart": "",
  "RuleVersion": "",
  "Rules": "",
  "DefaultValue": "",
  "SplitChargeRules": "",
  "ResourceTags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Name' => '',
  'EffectiveStart' => '',
  'RuleVersion' => '',
  'Rules' => '',
  'DefaultValue' => '',
  'SplitChargeRules' => '',
  'ResourceTags' => ''
]));

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

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

append(json_encode([
  'Name' => '',
  'EffectiveStart' => '',
  'RuleVersion' => '',
  'Rules' => '',
  'DefaultValue' => '',
  'SplitChargeRules' => '',
  'ResourceTags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateCostCategoryDefinition');
$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=AWSInsightsIndexService.CreateCostCategoryDefinition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "EffectiveStart": "",
  "RuleVersion": "",
  "Rules": "",
  "DefaultValue": "",
  "SplitChargeRules": "",
  "ResourceTags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateCostCategoryDefinition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Name": "",
  "EffectiveStart": "",
  "RuleVersion": "",
  "Rules": "",
  "DefaultValue": "",
  "SplitChargeRules": "",
  "ResourceTags": ""
}'

import http.client

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

payload = "{\n  \"Name\": \"\",\n  \"EffectiveStart\": \"\",\n  \"RuleVersion\": \"\",\n  \"Rules\": \"\",\n  \"DefaultValue\": \"\",\n  \"SplitChargeRules\": \"\",\n  \"ResourceTags\": \"\"\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=AWSInsightsIndexService.CreateCostCategoryDefinition"

payload = {
    "Name": "",
    "EffectiveStart": "",
    "RuleVersion": "",
    "Rules": "",
    "DefaultValue": "",
    "SplitChargeRules": "",
    "ResourceTags": ""
}
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=AWSInsightsIndexService.CreateCostCategoryDefinition"

payload <- "{\n  \"Name\": \"\",\n  \"EffectiveStart\": \"\",\n  \"RuleVersion\": \"\",\n  \"Rules\": \"\",\n  \"DefaultValue\": \"\",\n  \"SplitChargeRules\": \"\",\n  \"ResourceTags\": \"\"\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=AWSInsightsIndexService.CreateCostCategoryDefinition")

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  \"EffectiveStart\": \"\",\n  \"RuleVersion\": \"\",\n  \"Rules\": \"\",\n  \"DefaultValue\": \"\",\n  \"SplitChargeRules\": \"\",\n  \"ResourceTags\": \"\"\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  \"EffectiveStart\": \"\",\n  \"RuleVersion\": \"\",\n  \"Rules\": \"\",\n  \"DefaultValue\": \"\",\n  \"SplitChargeRules\": \"\",\n  \"ResourceTags\": \"\"\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=AWSInsightsIndexService.CreateCostCategoryDefinition";

    let payload = json!({
        "Name": "",
        "EffectiveStart": "",
        "RuleVersion": "",
        "Rules": "",
        "DefaultValue": "",
        "SplitChargeRules": "",
        "ResourceTags": ""
    });

    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=AWSInsightsIndexService.CreateCostCategoryDefinition' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Name": "",
  "EffectiveStart": "",
  "RuleVersion": "",
  "Rules": "",
  "DefaultValue": "",
  "SplitChargeRules": "",
  "ResourceTags": ""
}'

echo '{
  "Name": "",
  "EffectiveStart": "",
  "RuleVersion": "",
  "Rules": "",
  "DefaultValue": "",
  "SplitChargeRules": "",
  "ResourceTags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateCostCategoryDefinition' \
  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  "EffectiveStart": "",\n  "RuleVersion": "",\n  "Rules": "",\n  "DefaultValue": "",\n  "SplitChargeRules": "",\n  "ResourceTags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.CreateCostCategoryDefinition'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Name": "",
  "EffectiveStart": "",
  "RuleVersion": "",
  "Rules": "",
  "DefaultValue": "",
  "SplitChargeRules": "",
  "ResourceTags": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.DeleteAnomalyMonitor

HEADERS

X-Amz-Target

BODY json

{
  "MonitorArn": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.DeleteAnomalyMonitor" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:MonitorArn ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.DeleteAnomalyMonitor"

	payload := strings.NewReader("{\n  \"MonitorArn\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 22

{
  "MonitorArn": ""
}

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

client.close();

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

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

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=AWSInsightsIndexService.DeleteAnomalyMonitor');
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=AWSInsightsIndexService.DeleteAnomalyMonitor',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {MonitorArn: ''}
};

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

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

try {
  const response = await 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=AWSInsightsIndexService.DeleteAnomalyMonitor',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "MonitorArn": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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=AWSInsightsIndexService.DeleteAnomalyMonitor',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {MonitorArn: ''}
};

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=AWSInsightsIndexService.DeleteAnomalyMonitor';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"MonitorArn":""}'
};

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.DeleteAnomalyMonitor",
  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([
    'MonitorArn' => ''
  ]),
  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=AWSInsightsIndexService.DeleteAnomalyMonitor', [
  'body' => '{
  "MonitorArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'MonitorArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.DeleteAnomalyMonitor');
$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=AWSInsightsIndexService.DeleteAnomalyMonitor' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MonitorArn": ""
}'

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

import http.client

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

payload = "{\n  \"MonitorArn\": \"\"\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=AWSInsightsIndexService.DeleteAnomalyMonitor"

payload = { "MonitorArn": "" }
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=AWSInsightsIndexService.DeleteAnomalyMonitor"

payload <- "{\n  \"MonitorArn\": \"\"\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=AWSInsightsIndexService.DeleteAnomalyMonitor")

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  \"MonitorArn\": \"\"\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  \"MonitorArn\": \"\"\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=AWSInsightsIndexService.DeleteAnomalyMonitor";

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

    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=AWSInsightsIndexService.DeleteAnomalyMonitor' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "MonitorArn": ""
}'

echo '{
  "MonitorArn": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.DeleteAnomalyMonitor' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.DeleteAnomalySubscription

HEADERS

X-Amz-Target

BODY json

{
  "SubscriptionArn": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.DeleteAnomalySubscription" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:SubscriptionArn ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.DeleteAnomalySubscription"

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

{
  "SubscriptionArn": ""
}

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

client.close();

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

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

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=AWSInsightsIndexService.DeleteAnomalySubscription');
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=AWSInsightsIndexService.DeleteAnomalySubscription',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {SubscriptionArn: ''}
};

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

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

try {
  const response = await 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=AWSInsightsIndexService.DeleteAnomalySubscription',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SubscriptionArn": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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=AWSInsightsIndexService.DeleteAnomalySubscription',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {SubscriptionArn: ''}
};

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=AWSInsightsIndexService.DeleteAnomalySubscription';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SubscriptionArn":""}'
};

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.DeleteAnomalySubscription",
  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([
    'SubscriptionArn' => ''
  ]),
  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=AWSInsightsIndexService.DeleteAnomalySubscription', [
  'body' => '{
  "SubscriptionArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'SubscriptionArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.DeleteAnomalySubscription');
$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=AWSInsightsIndexService.DeleteAnomalySubscription' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SubscriptionArn": ""
}'

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

import http.client

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

payload = "{\n  \"SubscriptionArn\": \"\"\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=AWSInsightsIndexService.DeleteAnomalySubscription"

payload = { "SubscriptionArn": "" }
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=AWSInsightsIndexService.DeleteAnomalySubscription"

payload <- "{\n  \"SubscriptionArn\": \"\"\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=AWSInsightsIndexService.DeleteAnomalySubscription")

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  \"SubscriptionArn\": \"\"\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  \"SubscriptionArn\": \"\"\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=AWSInsightsIndexService.DeleteAnomalySubscription";

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

    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=AWSInsightsIndexService.DeleteAnomalySubscription' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "SubscriptionArn": ""
}'

echo '{
  "SubscriptionArn": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.DeleteAnomalySubscription' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.DeleteCostCategoryDefinition

HEADERS

X-Amz-Target

BODY json

{
  "CostCategoryArn": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.DeleteCostCategoryDefinition" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:CostCategoryArn ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.DeleteCostCategoryDefinition"

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

{
  "CostCategoryArn": ""
}

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

client.close();

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

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

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=AWSInsightsIndexService.DeleteCostCategoryDefinition');
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=AWSInsightsIndexService.DeleteCostCategoryDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CostCategoryArn: ''}
};

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

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

try {
  const response = await 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=AWSInsightsIndexService.DeleteCostCategoryDefinition',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CostCategoryArn": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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=AWSInsightsIndexService.DeleteCostCategoryDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CostCategoryArn: ''}
};

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=AWSInsightsIndexService.DeleteCostCategoryDefinition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CostCategoryArn":""}'
};

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.DeleteCostCategoryDefinition",
  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([
    'CostCategoryArn' => ''
  ]),
  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=AWSInsightsIndexService.DeleteCostCategoryDefinition', [
  'body' => '{
  "CostCategoryArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'CostCategoryArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.DeleteCostCategoryDefinition');
$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=AWSInsightsIndexService.DeleteCostCategoryDefinition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CostCategoryArn": ""
}'

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

import http.client

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

payload = "{\n  \"CostCategoryArn\": \"\"\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=AWSInsightsIndexService.DeleteCostCategoryDefinition"

payload = { "CostCategoryArn": "" }
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=AWSInsightsIndexService.DeleteCostCategoryDefinition"

payload <- "{\n  \"CostCategoryArn\": \"\"\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=AWSInsightsIndexService.DeleteCostCategoryDefinition")

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  \"CostCategoryArn\": \"\"\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  \"CostCategoryArn\": \"\"\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=AWSInsightsIndexService.DeleteCostCategoryDefinition";

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

    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=AWSInsightsIndexService.DeleteCostCategoryDefinition' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "CostCategoryArn": ""
}'

echo '{
  "CostCategoryArn": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.DeleteCostCategoryDefinition' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.DescribeCostCategoryDefinition

HEADERS

X-Amz-Target

BODY json

{
  "CostCategoryArn": "",
  "EffectiveOn": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.DescribeCostCategoryDefinition" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:CostCategoryArn ""
                                                                                                                               :EffectiveOn ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.DescribeCostCategoryDefinition"

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

{
  "CostCategoryArn": "",
  "EffectiveOn": ""
}

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

client.close();

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

const data = JSON.stringify({
  CostCategoryArn: '',
  EffectiveOn: ''
});

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=AWSInsightsIndexService.DescribeCostCategoryDefinition');
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=AWSInsightsIndexService.DescribeCostCategoryDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CostCategoryArn: '', EffectiveOn: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.DescribeCostCategoryDefinition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CostCategoryArn":"","EffectiveOn":""}'
};

try {
  const response = await 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=AWSInsightsIndexService.DescribeCostCategoryDefinition',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CostCategoryArn": "",\n  "EffectiveOn": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CostCategoryArn\": \"\",\n  \"EffectiveOn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.DescribeCostCategoryDefinition")
  .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({CostCategoryArn: '', EffectiveOn: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  CostCategoryArn: '',
  EffectiveOn: ''
});

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=AWSInsightsIndexService.DescribeCostCategoryDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CostCategoryArn: '', EffectiveOn: ''}
};

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=AWSInsightsIndexService.DescribeCostCategoryDefinition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CostCategoryArn":"","EffectiveOn":""}'
};

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.DescribeCostCategoryDefinition",
  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([
    'CostCategoryArn' => '',
    'EffectiveOn' => ''
  ]),
  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=AWSInsightsIndexService.DescribeCostCategoryDefinition', [
  'body' => '{
  "CostCategoryArn": "",
  "EffectiveOn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'CostCategoryArn' => '',
  'EffectiveOn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.DescribeCostCategoryDefinition');
$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=AWSInsightsIndexService.DescribeCostCategoryDefinition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CostCategoryArn": "",
  "EffectiveOn": ""
}'

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

import http.client

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

payload = "{\n  \"CostCategoryArn\": \"\",\n  \"EffectiveOn\": \"\"\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=AWSInsightsIndexService.DescribeCostCategoryDefinition"

payload = {
    "CostCategoryArn": "",
    "EffectiveOn": ""
}
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=AWSInsightsIndexService.DescribeCostCategoryDefinition"

payload <- "{\n  \"CostCategoryArn\": \"\",\n  \"EffectiveOn\": \"\"\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=AWSInsightsIndexService.DescribeCostCategoryDefinition")

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  \"CostCategoryArn\": \"\",\n  \"EffectiveOn\": \"\"\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  \"CostCategoryArn\": \"\",\n  \"EffectiveOn\": \"\"\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=AWSInsightsIndexService.DescribeCostCategoryDefinition";

    let payload = json!({
        "CostCategoryArn": "",
        "EffectiveOn": ""
    });

    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=AWSInsightsIndexService.DescribeCostCategoryDefinition' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "CostCategoryArn": "",
  "EffectiveOn": ""
}'

echo '{
  "CostCategoryArn": "",
  "EffectiveOn": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.DescribeCostCategoryDefinition' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalies

HEADERS

X-Amz-Target

BODY json

{
  "MonitorArn": "",
  "DateInterval": "",
  "Feedback": "",
  "TotalImpact": "",
  "NextPageToken": "",
  "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=AWSInsightsIndexService.GetAnomalies");

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  \"MonitorArn\": \"\",\n  \"DateInterval\": \"\",\n  \"Feedback\": \"\",\n  \"TotalImpact\": \"\",\n  \"NextPageToken\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalies" {:headers {:x-amz-target ""}
                                                                                               :content-type :json
                                                                                               :form-params {:MonitorArn ""
                                                                                                             :DateInterval ""
                                                                                                             :Feedback ""
                                                                                                             :TotalImpact ""
                                                                                                             :NextPageToken ""
                                                                                                             :MaxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalies"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"MonitorArn\": \"\",\n  \"DateInterval\": \"\",\n  \"Feedback\": \"\",\n  \"TotalImpact\": \"\",\n  \"NextPageToken\": \"\",\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=AWSInsightsIndexService.GetAnomalies"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"MonitorArn\": \"\",\n  \"DateInterval\": \"\",\n  \"Feedback\": \"\",\n  \"TotalImpact\": \"\",\n  \"NextPageToken\": \"\",\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=AWSInsightsIndexService.GetAnomalies");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"MonitorArn\": \"\",\n  \"DateInterval\": \"\",\n  \"Feedback\": \"\",\n  \"TotalImpact\": \"\",\n  \"NextPageToken\": \"\",\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=AWSInsightsIndexService.GetAnomalies"

	payload := strings.NewReader("{\n  \"MonitorArn\": \"\",\n  \"DateInterval\": \"\",\n  \"Feedback\": \"\",\n  \"TotalImpact\": \"\",\n  \"NextPageToken\": \"\",\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: 126

{
  "MonitorArn": "",
  "DateInterval": "",
  "Feedback": "",
  "TotalImpact": "",
  "NextPageToken": "",
  "MaxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalies")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"MonitorArn\": \"\",\n  \"DateInterval\": \"\",\n  \"Feedback\": \"\",\n  \"TotalImpact\": \"\",\n  \"NextPageToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalies"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"MonitorArn\": \"\",\n  \"DateInterval\": \"\",\n  \"Feedback\": \"\",\n  \"TotalImpact\": \"\",\n  \"NextPageToken\": \"\",\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  \"MonitorArn\": \"\",\n  \"DateInterval\": \"\",\n  \"Feedback\": \"\",\n  \"TotalImpact\": \"\",\n  \"NextPageToken\": \"\",\n  \"MaxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalies")
  .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=AWSInsightsIndexService.GetAnomalies")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"MonitorArn\": \"\",\n  \"DateInterval\": \"\",\n  \"Feedback\": \"\",\n  \"TotalImpact\": \"\",\n  \"NextPageToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  MonitorArn: '',
  DateInterval: '',
  Feedback: '',
  TotalImpact: '',
  NextPageToken: '',
  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=AWSInsightsIndexService.GetAnomalies');
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=AWSInsightsIndexService.GetAnomalies',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    MonitorArn: '',
    DateInterval: '',
    Feedback: '',
    TotalImpact: '',
    NextPageToken: '',
    MaxResults: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalies';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"MonitorArn":"","DateInterval":"","Feedback":"","TotalImpact":"","NextPageToken":"","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=AWSInsightsIndexService.GetAnomalies',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "MonitorArn": "",\n  "DateInterval": "",\n  "Feedback": "",\n  "TotalImpact": "",\n  "NextPageToken": "",\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  \"MonitorArn\": \"\",\n  \"DateInterval\": \"\",\n  \"Feedback\": \"\",\n  \"TotalImpact\": \"\",\n  \"NextPageToken\": \"\",\n  \"MaxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalies")
  .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({
  MonitorArn: '',
  DateInterval: '',
  Feedback: '',
  TotalImpact: '',
  NextPageToken: '',
  MaxResults: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalies',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    MonitorArn: '',
    DateInterval: '',
    Feedback: '',
    TotalImpact: '',
    NextPageToken: '',
    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=AWSInsightsIndexService.GetAnomalies');

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

req.type('json');
req.send({
  MonitorArn: '',
  DateInterval: '',
  Feedback: '',
  TotalImpact: '',
  NextPageToken: '',
  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=AWSInsightsIndexService.GetAnomalies',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    MonitorArn: '',
    DateInterval: '',
    Feedback: '',
    TotalImpact: '',
    NextPageToken: '',
    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=AWSInsightsIndexService.GetAnomalies';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"MonitorArn":"","DateInterval":"","Feedback":"","TotalImpact":"","NextPageToken":"","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 = @{ @"MonitorArn": @"",
                              @"DateInterval": @"",
                              @"Feedback": @"",
                              @"TotalImpact": @"",
                              @"NextPageToken": @"",
                              @"MaxResults": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalies",
  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([
    'MonitorArn' => '',
    'DateInterval' => '',
    'Feedback' => '',
    'TotalImpact' => '',
    'NextPageToken' => '',
    '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=AWSInsightsIndexService.GetAnomalies', [
  'body' => '{
  "MonitorArn": "",
  "DateInterval": "",
  "Feedback": "",
  "TotalImpact": "",
  "NextPageToken": "",
  "MaxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'MonitorArn' => '',
  'DateInterval' => '',
  'Feedback' => '',
  'TotalImpact' => '',
  'NextPageToken' => '',
  'MaxResults' => ''
]));

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

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

append(json_encode([
  'MonitorArn' => '',
  'DateInterval' => '',
  'Feedback' => '',
  'TotalImpact' => '',
  'NextPageToken' => '',
  'MaxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalies');
$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=AWSInsightsIndexService.GetAnomalies' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MonitorArn": "",
  "DateInterval": "",
  "Feedback": "",
  "TotalImpact": "",
  "NextPageToken": "",
  "MaxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalies' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MonitorArn": "",
  "DateInterval": "",
  "Feedback": "",
  "TotalImpact": "",
  "NextPageToken": "",
  "MaxResults": ""
}'

import http.client

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

payload = "{\n  \"MonitorArn\": \"\",\n  \"DateInterval\": \"\",\n  \"Feedback\": \"\",\n  \"TotalImpact\": \"\",\n  \"NextPageToken\": \"\",\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=AWSInsightsIndexService.GetAnomalies"

payload = {
    "MonitorArn": "",
    "DateInterval": "",
    "Feedback": "",
    "TotalImpact": "",
    "NextPageToken": "",
    "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=AWSInsightsIndexService.GetAnomalies"

payload <- "{\n  \"MonitorArn\": \"\",\n  \"DateInterval\": \"\",\n  \"Feedback\": \"\",\n  \"TotalImpact\": \"\",\n  \"NextPageToken\": \"\",\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=AWSInsightsIndexService.GetAnomalies")

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  \"MonitorArn\": \"\",\n  \"DateInterval\": \"\",\n  \"Feedback\": \"\",\n  \"TotalImpact\": \"\",\n  \"NextPageToken\": \"\",\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  \"MonitorArn\": \"\",\n  \"DateInterval\": \"\",\n  \"Feedback\": \"\",\n  \"TotalImpact\": \"\",\n  \"NextPageToken\": \"\",\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=AWSInsightsIndexService.GetAnomalies";

    let payload = json!({
        "MonitorArn": "",
        "DateInterval": "",
        "Feedback": "",
        "TotalImpact": "",
        "NextPageToken": "",
        "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=AWSInsightsIndexService.GetAnomalies' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "MonitorArn": "",
  "DateInterval": "",
  "Feedback": "",
  "TotalImpact": "",
  "NextPageToken": "",
  "MaxResults": ""
}'

echo '{
  "MonitorArn": "",
  "DateInterval": "",
  "Feedback": "",
  "TotalImpact": "",
  "NextPageToken": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalies' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "MonitorArn": "",\n  "DateInterval": "",\n  "Feedback": "",\n  "TotalImpact": "",\n  "NextPageToken": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalies'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "MonitorArn": "",
  "DateInterval": "",
  "Feedback": "",
  "TotalImpact": "",
  "NextPageToken": "",
  "MaxResults": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalyMonitors

HEADERS

X-Amz-Target

BODY json

{
  "MonitorArnList": "",
  "NextPageToken": "",
  "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=AWSInsightsIndexService.GetAnomalyMonitors");

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  \"MonitorArnList\": \"\",\n  \"NextPageToken\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalyMonitors" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:MonitorArnList ""
                                                                                                                   :NextPageToken ""
                                                                                                                   :MaxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalyMonitors"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"MonitorArnList\": \"\",\n  \"NextPageToken\": \"\",\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=AWSInsightsIndexService.GetAnomalyMonitors"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"MonitorArnList\": \"\",\n  \"NextPageToken\": \"\",\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=AWSInsightsIndexService.GetAnomalyMonitors");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"MonitorArnList\": \"\",\n  \"NextPageToken\": \"\",\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=AWSInsightsIndexService.GetAnomalyMonitors"

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

{
  "MonitorArnList": "",
  "NextPageToken": "",
  "MaxResults": ""
}

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

client.close();

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

const data = JSON.stringify({
  MonitorArnList: '',
  NextPageToken: '',
  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=AWSInsightsIndexService.GetAnomalyMonitors');
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=AWSInsightsIndexService.GetAnomalyMonitors',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {MonitorArnList: '', NextPageToken: '', MaxResults: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalyMonitors';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"MonitorArnList":"","NextPageToken":"","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=AWSInsightsIndexService.GetAnomalyMonitors',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "MonitorArnList": "",\n  "NextPageToken": "",\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  \"MonitorArnList\": \"\",\n  \"NextPageToken\": \"\",\n  \"MaxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalyMonitors")
  .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({MonitorArnList: '', NextPageToken: '', MaxResults: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  MonitorArnList: '',
  NextPageToken: '',
  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=AWSInsightsIndexService.GetAnomalyMonitors',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {MonitorArnList: '', NextPageToken: '', 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=AWSInsightsIndexService.GetAnomalyMonitors';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"MonitorArnList":"","NextPageToken":"","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 = @{ @"MonitorArnList": @"",
                              @"NextPageToken": @"",
                              @"MaxResults": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalyMonitors",
  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([
    'MonitorArnList' => '',
    'NextPageToken' => '',
    '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=AWSInsightsIndexService.GetAnomalyMonitors', [
  'body' => '{
  "MonitorArnList": "",
  "NextPageToken": "",
  "MaxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'MonitorArnList' => '',
  'NextPageToken' => '',
  'MaxResults' => ''
]));

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

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

append(json_encode([
  'MonitorArnList' => '',
  'NextPageToken' => '',
  'MaxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalyMonitors');
$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=AWSInsightsIndexService.GetAnomalyMonitors' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MonitorArnList": "",
  "NextPageToken": "",
  "MaxResults": ""
}'

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

import http.client

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

payload = "{\n  \"MonitorArnList\": \"\",\n  \"NextPageToken\": \"\",\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=AWSInsightsIndexService.GetAnomalyMonitors"

payload = {
    "MonitorArnList": "",
    "NextPageToken": "",
    "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=AWSInsightsIndexService.GetAnomalyMonitors"

payload <- "{\n  \"MonitorArnList\": \"\",\n  \"NextPageToken\": \"\",\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=AWSInsightsIndexService.GetAnomalyMonitors")

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  \"MonitorArnList\": \"\",\n  \"NextPageToken\": \"\",\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  \"MonitorArnList\": \"\",\n  \"NextPageToken\": \"\",\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=AWSInsightsIndexService.GetAnomalyMonitors";

    let payload = json!({
        "MonitorArnList": "",
        "NextPageToken": "",
        "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=AWSInsightsIndexService.GetAnomalyMonitors' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "MonitorArnList": "",
  "NextPageToken": "",
  "MaxResults": ""
}'

echo '{
  "MonitorArnList": "",
  "NextPageToken": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalyMonitors' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "MonitorArnList": "",\n  "NextPageToken": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalyMonitors'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalySubscriptions

HEADERS

X-Amz-Target

BODY json

{
  "SubscriptionArnList": "",
  "MonitorArn": "",
  "NextPageToken": "",
  "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=AWSInsightsIndexService.GetAnomalySubscriptions");

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  \"SubscriptionArnList\": \"\",\n  \"MonitorArn\": \"\",\n  \"NextPageToken\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalySubscriptions" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:SubscriptionArnList ""
                                                                                                                        :MonitorArn ""
                                                                                                                        :NextPageToken ""
                                                                                                                        :MaxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalySubscriptions"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"SubscriptionArnList\": \"\",\n  \"MonitorArn\": \"\",\n  \"NextPageToken\": \"\",\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=AWSInsightsIndexService.GetAnomalySubscriptions"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"SubscriptionArnList\": \"\",\n  \"MonitorArn\": \"\",\n  \"NextPageToken\": \"\",\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=AWSInsightsIndexService.GetAnomalySubscriptions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"SubscriptionArnList\": \"\",\n  \"MonitorArn\": \"\",\n  \"NextPageToken\": \"\",\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=AWSInsightsIndexService.GetAnomalySubscriptions"

	payload := strings.NewReader("{\n  \"SubscriptionArnList\": \"\",\n  \"MonitorArn\": \"\",\n  \"NextPageToken\": \"\",\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: 94

{
  "SubscriptionArnList": "",
  "MonitorArn": "",
  "NextPageToken": "",
  "MaxResults": ""
}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalySubscriptions"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"SubscriptionArnList\": \"\",\n  \"MonitorArn\": \"\",\n  \"NextPageToken\": \"\",\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  \"SubscriptionArnList\": \"\",\n  \"MonitorArn\": \"\",\n  \"NextPageToken\": \"\",\n  \"MaxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalySubscriptions")
  .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=AWSInsightsIndexService.GetAnomalySubscriptions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"SubscriptionArnList\": \"\",\n  \"MonitorArn\": \"\",\n  \"NextPageToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  SubscriptionArnList: '',
  MonitorArn: '',
  NextPageToken: '',
  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=AWSInsightsIndexService.GetAnomalySubscriptions');
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=AWSInsightsIndexService.GetAnomalySubscriptions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {SubscriptionArnList: '', MonitorArn: '', NextPageToken: '', MaxResults: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalySubscriptions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SubscriptionArnList":"","MonitorArn":"","NextPageToken":"","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=AWSInsightsIndexService.GetAnomalySubscriptions',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SubscriptionArnList": "",\n  "MonitorArn": "",\n  "NextPageToken": "",\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  \"SubscriptionArnList\": \"\",\n  \"MonitorArn\": \"\",\n  \"NextPageToken\": \"\",\n  \"MaxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalySubscriptions")
  .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({SubscriptionArnList: '', MonitorArn: '', NextPageToken: '', MaxResults: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  SubscriptionArnList: '',
  MonitorArn: '',
  NextPageToken: '',
  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=AWSInsightsIndexService.GetAnomalySubscriptions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {SubscriptionArnList: '', MonitorArn: '', NextPageToken: '', 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=AWSInsightsIndexService.GetAnomalySubscriptions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SubscriptionArnList":"","MonitorArn":"","NextPageToken":"","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 = @{ @"SubscriptionArnList": @"",
                              @"MonitorArn": @"",
                              @"NextPageToken": @"",
                              @"MaxResults": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalySubscriptions",
  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([
    'SubscriptionArnList' => '',
    'MonitorArn' => '',
    'NextPageToken' => '',
    '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=AWSInsightsIndexService.GetAnomalySubscriptions', [
  'body' => '{
  "SubscriptionArnList": "",
  "MonitorArn": "",
  "NextPageToken": "",
  "MaxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'SubscriptionArnList' => '',
  'MonitorArn' => '',
  'NextPageToken' => '',
  'MaxResults' => ''
]));

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

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

append(json_encode([
  'SubscriptionArnList' => '',
  'MonitorArn' => '',
  'NextPageToken' => '',
  'MaxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalySubscriptions');
$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=AWSInsightsIndexService.GetAnomalySubscriptions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SubscriptionArnList": "",
  "MonitorArn": "",
  "NextPageToken": "",
  "MaxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalySubscriptions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SubscriptionArnList": "",
  "MonitorArn": "",
  "NextPageToken": "",
  "MaxResults": ""
}'

import http.client

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

payload = "{\n  \"SubscriptionArnList\": \"\",\n  \"MonitorArn\": \"\",\n  \"NextPageToken\": \"\",\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=AWSInsightsIndexService.GetAnomalySubscriptions"

payload = {
    "SubscriptionArnList": "",
    "MonitorArn": "",
    "NextPageToken": "",
    "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=AWSInsightsIndexService.GetAnomalySubscriptions"

payload <- "{\n  \"SubscriptionArnList\": \"\",\n  \"MonitorArn\": \"\",\n  \"NextPageToken\": \"\",\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=AWSInsightsIndexService.GetAnomalySubscriptions")

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  \"SubscriptionArnList\": \"\",\n  \"MonitorArn\": \"\",\n  \"NextPageToken\": \"\",\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  \"SubscriptionArnList\": \"\",\n  \"MonitorArn\": \"\",\n  \"NextPageToken\": \"\",\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=AWSInsightsIndexService.GetAnomalySubscriptions";

    let payload = json!({
        "SubscriptionArnList": "",
        "MonitorArn": "",
        "NextPageToken": "",
        "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=AWSInsightsIndexService.GetAnomalySubscriptions' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "SubscriptionArnList": "",
  "MonitorArn": "",
  "NextPageToken": "",
  "MaxResults": ""
}'

echo '{
  "SubscriptionArnList": "",
  "MonitorArn": "",
  "NextPageToken": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalySubscriptions' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "SubscriptionArnList": "",\n  "MonitorArn": "",\n  "NextPageToken": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetAnomalySubscriptions'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsage

HEADERS

X-Amz-Target

BODY json

{
  "TimePeriod": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "GroupBy": "",
  "NextPageToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"GroupBy\": \"\",\n  \"NextPageToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsage" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:TimePeriod ""
                                                                                                                :Granularity ""
                                                                                                                :Filter ""
                                                                                                                :Metrics ""
                                                                                                                :GroupBy ""
                                                                                                                :NextPageToken ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsage"

	payload := strings.NewReader("{\n  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"GroupBy\": \"\",\n  \"NextPageToken\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 116

{
  "TimePeriod": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "GroupBy": "",
  "NextPageToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsage")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"GroupBy\": \"\",\n  \"NextPageToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsage"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"GroupBy\": \"\",\n  \"NextPageToken\": \"\"\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  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"GroupBy\": \"\",\n  \"NextPageToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsage")
  .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=AWSInsightsIndexService.GetCostAndUsage")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"GroupBy\": \"\",\n  \"NextPageToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TimePeriod: '',
  Granularity: '',
  Filter: '',
  Metrics: '',
  GroupBy: '',
  NextPageToken: ''
});

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=AWSInsightsIndexService.GetCostAndUsage');
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=AWSInsightsIndexService.GetCostAndUsage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TimePeriod: '',
    Granularity: '',
    Filter: '',
    Metrics: '',
    GroupBy: '',
    NextPageToken: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsage';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TimePeriod":"","Granularity":"","Filter":"","Metrics":"","GroupBy":"","NextPageToken":""}'
};

try {
  const response = await 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=AWSInsightsIndexService.GetCostAndUsage',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TimePeriod": "",\n  "Granularity": "",\n  "Filter": "",\n  "Metrics": "",\n  "GroupBy": "",\n  "NextPageToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"GroupBy\": \"\",\n  \"NextPageToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsage")
  .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({
  TimePeriod: '',
  Granularity: '',
  Filter: '',
  Metrics: '',
  GroupBy: '',
  NextPageToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    TimePeriod: '',
    Granularity: '',
    Filter: '',
    Metrics: '',
    GroupBy: '',
    NextPageToken: ''
  },
  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=AWSInsightsIndexService.GetCostAndUsage');

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

req.type('json');
req.send({
  TimePeriod: '',
  Granularity: '',
  Filter: '',
  Metrics: '',
  GroupBy: '',
  NextPageToken: ''
});

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=AWSInsightsIndexService.GetCostAndUsage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TimePeriod: '',
    Granularity: '',
    Filter: '',
    Metrics: '',
    GroupBy: '',
    NextPageToken: ''
  }
};

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=AWSInsightsIndexService.GetCostAndUsage';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TimePeriod":"","Granularity":"","Filter":"","Metrics":"","GroupBy":"","NextPageToken":""}'
};

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 = @{ @"TimePeriod": @"",
                              @"Granularity": @"",
                              @"Filter": @"",
                              @"Metrics": @"",
                              @"GroupBy": @"",
                              @"NextPageToken": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsage",
  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([
    'TimePeriod' => '',
    'Granularity' => '',
    'Filter' => '',
    'Metrics' => '',
    'GroupBy' => '',
    'NextPageToken' => ''
  ]),
  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=AWSInsightsIndexService.GetCostAndUsage', [
  'body' => '{
  "TimePeriod": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "GroupBy": "",
  "NextPageToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TimePeriod' => '',
  'Granularity' => '',
  'Filter' => '',
  'Metrics' => '',
  'GroupBy' => '',
  'NextPageToken' => ''
]));

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

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

append(json_encode([
  'TimePeriod' => '',
  'Granularity' => '',
  'Filter' => '',
  'Metrics' => '',
  'GroupBy' => '',
  'NextPageToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsage');
$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=AWSInsightsIndexService.GetCostAndUsage' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TimePeriod": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "GroupBy": "",
  "NextPageToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsage' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TimePeriod": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "GroupBy": "",
  "NextPageToken": ""
}'

import http.client

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

payload = "{\n  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"GroupBy\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetCostAndUsage"

payload = {
    "TimePeriod": "",
    "Granularity": "",
    "Filter": "",
    "Metrics": "",
    "GroupBy": "",
    "NextPageToken": ""
}
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=AWSInsightsIndexService.GetCostAndUsage"

payload <- "{\n  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"GroupBy\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetCostAndUsage")

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  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"GroupBy\": \"\",\n  \"NextPageToken\": \"\"\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  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"GroupBy\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetCostAndUsage";

    let payload = json!({
        "TimePeriod": "",
        "Granularity": "",
        "Filter": "",
        "Metrics": "",
        "GroupBy": "",
        "NextPageToken": ""
    });

    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=AWSInsightsIndexService.GetCostAndUsage' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "TimePeriod": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "GroupBy": "",
  "NextPageToken": ""
}'

echo '{
  "TimePeriod": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "GroupBy": "",
  "NextPageToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsage' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TimePeriod": "",\n  "Granularity": "",\n  "Filter": "",\n  "Metrics": "",\n  "GroupBy": "",\n  "NextPageToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsage'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TimePeriod": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "GroupBy": "",
  "NextPageToken": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsageWithResources

HEADERS

X-Amz-Target

BODY json

{
  "TimePeriod": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "GroupBy": "",
  "NextPageToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"GroupBy\": \"\",\n  \"NextPageToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsageWithResources" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:TimePeriod ""
                                                                                                                             :Granularity ""
                                                                                                                             :Filter ""
                                                                                                                             :Metrics ""
                                                                                                                             :GroupBy ""
                                                                                                                             :NextPageToken ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsageWithResources"

	payload := strings.NewReader("{\n  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"GroupBy\": \"\",\n  \"NextPageToken\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 116

{
  "TimePeriod": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "GroupBy": "",
  "NextPageToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsageWithResources")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"GroupBy\": \"\",\n  \"NextPageToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsageWithResources"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"GroupBy\": \"\",\n  \"NextPageToken\": \"\"\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  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"GroupBy\": \"\",\n  \"NextPageToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsageWithResources")
  .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=AWSInsightsIndexService.GetCostAndUsageWithResources")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"GroupBy\": \"\",\n  \"NextPageToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TimePeriod: '',
  Granularity: '',
  Filter: '',
  Metrics: '',
  GroupBy: '',
  NextPageToken: ''
});

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=AWSInsightsIndexService.GetCostAndUsageWithResources');
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=AWSInsightsIndexService.GetCostAndUsageWithResources',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TimePeriod: '',
    Granularity: '',
    Filter: '',
    Metrics: '',
    GroupBy: '',
    NextPageToken: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsageWithResources';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TimePeriod":"","Granularity":"","Filter":"","Metrics":"","GroupBy":"","NextPageToken":""}'
};

try {
  const response = await 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=AWSInsightsIndexService.GetCostAndUsageWithResources',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TimePeriod": "",\n  "Granularity": "",\n  "Filter": "",\n  "Metrics": "",\n  "GroupBy": "",\n  "NextPageToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"GroupBy\": \"\",\n  \"NextPageToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsageWithResources")
  .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({
  TimePeriod: '',
  Granularity: '',
  Filter: '',
  Metrics: '',
  GroupBy: '',
  NextPageToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsageWithResources',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    TimePeriod: '',
    Granularity: '',
    Filter: '',
    Metrics: '',
    GroupBy: '',
    NextPageToken: ''
  },
  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=AWSInsightsIndexService.GetCostAndUsageWithResources');

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

req.type('json');
req.send({
  TimePeriod: '',
  Granularity: '',
  Filter: '',
  Metrics: '',
  GroupBy: '',
  NextPageToken: ''
});

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=AWSInsightsIndexService.GetCostAndUsageWithResources',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TimePeriod: '',
    Granularity: '',
    Filter: '',
    Metrics: '',
    GroupBy: '',
    NextPageToken: ''
  }
};

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=AWSInsightsIndexService.GetCostAndUsageWithResources';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TimePeriod":"","Granularity":"","Filter":"","Metrics":"","GroupBy":"","NextPageToken":""}'
};

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 = @{ @"TimePeriod": @"",
                              @"Granularity": @"",
                              @"Filter": @"",
                              @"Metrics": @"",
                              @"GroupBy": @"",
                              @"NextPageToken": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsageWithResources",
  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([
    'TimePeriod' => '',
    'Granularity' => '',
    'Filter' => '',
    'Metrics' => '',
    'GroupBy' => '',
    'NextPageToken' => ''
  ]),
  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=AWSInsightsIndexService.GetCostAndUsageWithResources', [
  'body' => '{
  "TimePeriod": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "GroupBy": "",
  "NextPageToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TimePeriod' => '',
  'Granularity' => '',
  'Filter' => '',
  'Metrics' => '',
  'GroupBy' => '',
  'NextPageToken' => ''
]));

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

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

append(json_encode([
  'TimePeriod' => '',
  'Granularity' => '',
  'Filter' => '',
  'Metrics' => '',
  'GroupBy' => '',
  'NextPageToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsageWithResources');
$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=AWSInsightsIndexService.GetCostAndUsageWithResources' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TimePeriod": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "GroupBy": "",
  "NextPageToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsageWithResources' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TimePeriod": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "GroupBy": "",
  "NextPageToken": ""
}'

import http.client

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

payload = "{\n  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"GroupBy\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetCostAndUsageWithResources"

payload = {
    "TimePeriod": "",
    "Granularity": "",
    "Filter": "",
    "Metrics": "",
    "GroupBy": "",
    "NextPageToken": ""
}
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=AWSInsightsIndexService.GetCostAndUsageWithResources"

payload <- "{\n  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"GroupBy\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetCostAndUsageWithResources")

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  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"GroupBy\": \"\",\n  \"NextPageToken\": \"\"\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  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"GroupBy\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetCostAndUsageWithResources";

    let payload = json!({
        "TimePeriod": "",
        "Granularity": "",
        "Filter": "",
        "Metrics": "",
        "GroupBy": "",
        "NextPageToken": ""
    });

    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=AWSInsightsIndexService.GetCostAndUsageWithResources' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "TimePeriod": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "GroupBy": "",
  "NextPageToken": ""
}'

echo '{
  "TimePeriod": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "GroupBy": "",
  "NextPageToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsageWithResources' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TimePeriod": "",\n  "Granularity": "",\n  "Filter": "",\n  "Metrics": "",\n  "GroupBy": "",\n  "NextPageToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostAndUsageWithResources'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TimePeriod": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "GroupBy": "",
  "NextPageToken": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostCategories

HEADERS

X-Amz-Target

BODY json

{
  "SearchString": "",
  "TimePeriod": {
    "Start": "",
    "End": ""
  },
  "CostCategoryName": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "SortBy": "",
  "MaxResults": "",
  "NextPageToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"SearchString\": \"\",\n  \"TimePeriod\": {\n    \"Start\": \"\",\n    \"End\": \"\"\n  },\n  \"CostCategoryName\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostCategories" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:SearchString ""
                                                                                                                  :TimePeriod {:Start ""
                                                                                                                               :End ""}
                                                                                                                  :CostCategoryName ""
                                                                                                                  :Filter {:Or ""
                                                                                                                           :And ""
                                                                                                                           :Not ""
                                                                                                                           :Dimensions ""
                                                                                                                           :Tags ""
                                                                                                                           :CostCategories ""}
                                                                                                                  :SortBy ""
                                                                                                                  :MaxResults ""
                                                                                                                  :NextPageToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostCategories"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"SearchString\": \"\",\n  \"TimePeriod\": {\n    \"Start\": \"\",\n    \"End\": \"\"\n  },\n  \"CostCategoryName\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetCostCategories"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"SearchString\": \"\",\n  \"TimePeriod\": {\n    \"Start\": \"\",\n    \"End\": \"\"\n  },\n  \"CostCategoryName\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetCostCategories");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"SearchString\": \"\",\n  \"TimePeriod\": {\n    \"Start\": \"\",\n    \"End\": \"\"\n  },\n  \"CostCategoryName\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostCategories"

	payload := strings.NewReader("{\n  \"SearchString\": \"\",\n  \"TimePeriod\": {\n    \"Start\": \"\",\n    \"End\": \"\"\n  },\n  \"CostCategoryName\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\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: 289

{
  "SearchString": "",
  "TimePeriod": {
    "Start": "",
    "End": ""
  },
  "CostCategoryName": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "SortBy": "",
  "MaxResults": "",
  "NextPageToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostCategories")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"SearchString\": \"\",\n  \"TimePeriod\": {\n    \"Start\": \"\",\n    \"End\": \"\"\n  },\n  \"CostCategoryName\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostCategories"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"SearchString\": \"\",\n  \"TimePeriod\": {\n    \"Start\": \"\",\n    \"End\": \"\"\n  },\n  \"CostCategoryName\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\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  \"SearchString\": \"\",\n  \"TimePeriod\": {\n    \"Start\": \"\",\n    \"End\": \"\"\n  },\n  \"CostCategoryName\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostCategories")
  .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=AWSInsightsIndexService.GetCostCategories")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"SearchString\": \"\",\n  \"TimePeriod\": {\n    \"Start\": \"\",\n    \"End\": \"\"\n  },\n  \"CostCategoryName\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  SearchString: '',
  TimePeriod: {
    Start: '',
    End: ''
  },
  CostCategoryName: '',
  Filter: {
    Or: '',
    And: '',
    Not: '',
    Dimensions: '',
    Tags: '',
    CostCategories: ''
  },
  SortBy: '',
  MaxResults: '',
  NextPageToken: ''
});

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=AWSInsightsIndexService.GetCostCategories');
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=AWSInsightsIndexService.GetCostCategories',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    SearchString: '',
    TimePeriod: {Start: '', End: ''},
    CostCategoryName: '',
    Filter: {Or: '', And: '', Not: '', Dimensions: '', Tags: '', CostCategories: ''},
    SortBy: '',
    MaxResults: '',
    NextPageToken: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostCategories';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SearchString":"","TimePeriod":{"Start":"","End":""},"CostCategoryName":"","Filter":{"Or":"","And":"","Not":"","Dimensions":"","Tags":"","CostCategories":""},"SortBy":"","MaxResults":"","NextPageToken":""}'
};

try {
  const response = await 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=AWSInsightsIndexService.GetCostCategories',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SearchString": "",\n  "TimePeriod": {\n    "Start": "",\n    "End": ""\n  },\n  "CostCategoryName": "",\n  "Filter": {\n    "Or": "",\n    "And": "",\n    "Not": "",\n    "Dimensions": "",\n    "Tags": "",\n    "CostCategories": ""\n  },\n  "SortBy": "",\n  "MaxResults": "",\n  "NextPageToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"SearchString\": \"\",\n  \"TimePeriod\": {\n    \"Start\": \"\",\n    \"End\": \"\"\n  },\n  \"CostCategoryName\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostCategories")
  .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({
  SearchString: '',
  TimePeriod: {Start: '', End: ''},
  CostCategoryName: '',
  Filter: {Or: '', And: '', Not: '', Dimensions: '', Tags: '', CostCategories: ''},
  SortBy: '',
  MaxResults: '',
  NextPageToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostCategories',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    SearchString: '',
    TimePeriod: {Start: '', End: ''},
    CostCategoryName: '',
    Filter: {Or: '', And: '', Not: '', Dimensions: '', Tags: '', CostCategories: ''},
    SortBy: '',
    MaxResults: '',
    NextPageToken: ''
  },
  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=AWSInsightsIndexService.GetCostCategories');

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

req.type('json');
req.send({
  SearchString: '',
  TimePeriod: {
    Start: '',
    End: ''
  },
  CostCategoryName: '',
  Filter: {
    Or: '',
    And: '',
    Not: '',
    Dimensions: '',
    Tags: '',
    CostCategories: ''
  },
  SortBy: '',
  MaxResults: '',
  NextPageToken: ''
});

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=AWSInsightsIndexService.GetCostCategories',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    SearchString: '',
    TimePeriod: {Start: '', End: ''},
    CostCategoryName: '',
    Filter: {Or: '', And: '', Not: '', Dimensions: '', Tags: '', CostCategories: ''},
    SortBy: '',
    MaxResults: '',
    NextPageToken: ''
  }
};

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=AWSInsightsIndexService.GetCostCategories';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SearchString":"","TimePeriod":{"Start":"","End":""},"CostCategoryName":"","Filter":{"Or":"","And":"","Not":"","Dimensions":"","Tags":"","CostCategories":""},"SortBy":"","MaxResults":"","NextPageToken":""}'
};

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 = @{ @"SearchString": @"",
                              @"TimePeriod": @{ @"Start": @"", @"End": @"" },
                              @"CostCategoryName": @"",
                              @"Filter": @{ @"Or": @"", @"And": @"", @"Not": @"", @"Dimensions": @"", @"Tags": @"", @"CostCategories": @"" },
                              @"SortBy": @"",
                              @"MaxResults": @"",
                              @"NextPageToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostCategories"]
                                                       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=AWSInsightsIndexService.GetCostCategories" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"SearchString\": \"\",\n  \"TimePeriod\": {\n    \"Start\": \"\",\n    \"End\": \"\"\n  },\n  \"CostCategoryName\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostCategories",
  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([
    'SearchString' => '',
    'TimePeriod' => [
        'Start' => '',
        'End' => ''
    ],
    'CostCategoryName' => '',
    'Filter' => [
        'Or' => '',
        'And' => '',
        'Not' => '',
        'Dimensions' => '',
        'Tags' => '',
        'CostCategories' => ''
    ],
    'SortBy' => '',
    'MaxResults' => '',
    'NextPageToken' => ''
  ]),
  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=AWSInsightsIndexService.GetCostCategories', [
  'body' => '{
  "SearchString": "",
  "TimePeriod": {
    "Start": "",
    "End": ""
  },
  "CostCategoryName": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "SortBy": "",
  "MaxResults": "",
  "NextPageToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'SearchString' => '',
  'TimePeriod' => [
    'Start' => '',
    'End' => ''
  ],
  'CostCategoryName' => '',
  'Filter' => [
    'Or' => '',
    'And' => '',
    'Not' => '',
    'Dimensions' => '',
    'Tags' => '',
    'CostCategories' => ''
  ],
  'SortBy' => '',
  'MaxResults' => '',
  'NextPageToken' => ''
]));

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

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

append(json_encode([
  'SearchString' => '',
  'TimePeriod' => [
    'Start' => '',
    'End' => ''
  ],
  'CostCategoryName' => '',
  'Filter' => [
    'Or' => '',
    'And' => '',
    'Not' => '',
    'Dimensions' => '',
    'Tags' => '',
    'CostCategories' => ''
  ],
  'SortBy' => '',
  'MaxResults' => '',
  'NextPageToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostCategories');
$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=AWSInsightsIndexService.GetCostCategories' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SearchString": "",
  "TimePeriod": {
    "Start": "",
    "End": ""
  },
  "CostCategoryName": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "SortBy": "",
  "MaxResults": "",
  "NextPageToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostCategories' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SearchString": "",
  "TimePeriod": {
    "Start": "",
    "End": ""
  },
  "CostCategoryName": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "SortBy": "",
  "MaxResults": "",
  "NextPageToken": ""
}'

import http.client

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

payload = "{\n  \"SearchString\": \"\",\n  \"TimePeriod\": {\n    \"Start\": \"\",\n    \"End\": \"\"\n  },\n  \"CostCategoryName\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetCostCategories"

payload = {
    "SearchString": "",
    "TimePeriod": {
        "Start": "",
        "End": ""
    },
    "CostCategoryName": "",
    "Filter": {
        "Or": "",
        "And": "",
        "Not": "",
        "Dimensions": "",
        "Tags": "",
        "CostCategories": ""
    },
    "SortBy": "",
    "MaxResults": "",
    "NextPageToken": ""
}
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=AWSInsightsIndexService.GetCostCategories"

payload <- "{\n  \"SearchString\": \"\",\n  \"TimePeriod\": {\n    \"Start\": \"\",\n    \"End\": \"\"\n  },\n  \"CostCategoryName\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetCostCategories")

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  \"SearchString\": \"\",\n  \"TimePeriod\": {\n    \"Start\": \"\",\n    \"End\": \"\"\n  },\n  \"CostCategoryName\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\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  \"SearchString\": \"\",\n  \"TimePeriod\": {\n    \"Start\": \"\",\n    \"End\": \"\"\n  },\n  \"CostCategoryName\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetCostCategories";

    let payload = json!({
        "SearchString": "",
        "TimePeriod": json!({
            "Start": "",
            "End": ""
        }),
        "CostCategoryName": "",
        "Filter": json!({
            "Or": "",
            "And": "",
            "Not": "",
            "Dimensions": "",
            "Tags": "",
            "CostCategories": ""
        }),
        "SortBy": "",
        "MaxResults": "",
        "NextPageToken": ""
    });

    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=AWSInsightsIndexService.GetCostCategories' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "SearchString": "",
  "TimePeriod": {
    "Start": "",
    "End": ""
  },
  "CostCategoryName": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "SortBy": "",
  "MaxResults": "",
  "NextPageToken": ""
}'

echo '{
  "SearchString": "",
  "TimePeriod": {
    "Start": "",
    "End": ""
  },
  "CostCategoryName": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "SortBy": "",
  "MaxResults": "",
  "NextPageToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostCategories' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "SearchString": "",\n  "TimePeriod": {\n    "Start": "",\n    "End": ""\n  },\n  "CostCategoryName": "",\n  "Filter": {\n    "Or": "",\n    "And": "",\n    "Not": "",\n    "Dimensions": "",\n    "Tags": "",\n    "CostCategories": ""\n  },\n  "SortBy": "",\n  "MaxResults": "",\n  "NextPageToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostCategories'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "SearchString": "",
  "TimePeriod": [
    "Start": "",
    "End": ""
  ],
  "CostCategoryName": "",
  "Filter": [
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  ],
  "SortBy": "",
  "MaxResults": "",
  "NextPageToken": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostForecast

HEADERS

X-Amz-Target

BODY json

{
  "TimePeriod": "",
  "Metric": "",
  "Granularity": "",
  "Filter": "",
  "PredictionIntervalLevel": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"TimePeriod\": \"\",\n  \"Metric\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"PredictionIntervalLevel\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostForecast" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:TimePeriod ""
                                                                                                                :Metric ""
                                                                                                                :Granularity ""
                                                                                                                :Filter ""
                                                                                                                :PredictionIntervalLevel ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostForecast"

	payload := strings.NewReader("{\n  \"TimePeriod\": \"\",\n  \"Metric\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"PredictionIntervalLevel\": \"\"\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: 108

{
  "TimePeriod": "",
  "Metric": "",
  "Granularity": "",
  "Filter": "",
  "PredictionIntervalLevel": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostForecast")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TimePeriod\": \"\",\n  \"Metric\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"PredictionIntervalLevel\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostForecast"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TimePeriod\": \"\",\n  \"Metric\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"PredictionIntervalLevel\": \"\"\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  \"TimePeriod\": \"\",\n  \"Metric\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"PredictionIntervalLevel\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostForecast")
  .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=AWSInsightsIndexService.GetCostForecast")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TimePeriod\": \"\",\n  \"Metric\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"PredictionIntervalLevel\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TimePeriod: '',
  Metric: '',
  Granularity: '',
  Filter: '',
  PredictionIntervalLevel: ''
});

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=AWSInsightsIndexService.GetCostForecast');
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=AWSInsightsIndexService.GetCostForecast',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TimePeriod: '',
    Metric: '',
    Granularity: '',
    Filter: '',
    PredictionIntervalLevel: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostForecast';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TimePeriod":"","Metric":"","Granularity":"","Filter":"","PredictionIntervalLevel":""}'
};

try {
  const response = await 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=AWSInsightsIndexService.GetCostForecast',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TimePeriod": "",\n  "Metric": "",\n  "Granularity": "",\n  "Filter": "",\n  "PredictionIntervalLevel": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TimePeriod\": \"\",\n  \"Metric\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"PredictionIntervalLevel\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostForecast")
  .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({
  TimePeriod: '',
  Metric: '',
  Granularity: '',
  Filter: '',
  PredictionIntervalLevel: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostForecast',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    TimePeriod: '',
    Metric: '',
    Granularity: '',
    Filter: '',
    PredictionIntervalLevel: ''
  },
  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=AWSInsightsIndexService.GetCostForecast');

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

req.type('json');
req.send({
  TimePeriod: '',
  Metric: '',
  Granularity: '',
  Filter: '',
  PredictionIntervalLevel: ''
});

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=AWSInsightsIndexService.GetCostForecast',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TimePeriod: '',
    Metric: '',
    Granularity: '',
    Filter: '',
    PredictionIntervalLevel: ''
  }
};

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=AWSInsightsIndexService.GetCostForecast';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TimePeriod":"","Metric":"","Granularity":"","Filter":"","PredictionIntervalLevel":""}'
};

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 = @{ @"TimePeriod": @"",
                              @"Metric": @"",
                              @"Granularity": @"",
                              @"Filter": @"",
                              @"PredictionIntervalLevel": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostForecast",
  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([
    'TimePeriod' => '',
    'Metric' => '',
    'Granularity' => '',
    'Filter' => '',
    'PredictionIntervalLevel' => ''
  ]),
  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=AWSInsightsIndexService.GetCostForecast', [
  'body' => '{
  "TimePeriod": "",
  "Metric": "",
  "Granularity": "",
  "Filter": "",
  "PredictionIntervalLevel": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TimePeriod' => '',
  'Metric' => '',
  'Granularity' => '',
  'Filter' => '',
  'PredictionIntervalLevel' => ''
]));

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

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

append(json_encode([
  'TimePeriod' => '',
  'Metric' => '',
  'Granularity' => '',
  'Filter' => '',
  'PredictionIntervalLevel' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostForecast');
$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=AWSInsightsIndexService.GetCostForecast' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TimePeriod": "",
  "Metric": "",
  "Granularity": "",
  "Filter": "",
  "PredictionIntervalLevel": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostForecast' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TimePeriod": "",
  "Metric": "",
  "Granularity": "",
  "Filter": "",
  "PredictionIntervalLevel": ""
}'

import http.client

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

payload = "{\n  \"TimePeriod\": \"\",\n  \"Metric\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"PredictionIntervalLevel\": \"\"\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=AWSInsightsIndexService.GetCostForecast"

payload = {
    "TimePeriod": "",
    "Metric": "",
    "Granularity": "",
    "Filter": "",
    "PredictionIntervalLevel": ""
}
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=AWSInsightsIndexService.GetCostForecast"

payload <- "{\n  \"TimePeriod\": \"\",\n  \"Metric\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"PredictionIntervalLevel\": \"\"\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=AWSInsightsIndexService.GetCostForecast")

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  \"TimePeriod\": \"\",\n  \"Metric\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"PredictionIntervalLevel\": \"\"\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  \"TimePeriod\": \"\",\n  \"Metric\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"PredictionIntervalLevel\": \"\"\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=AWSInsightsIndexService.GetCostForecast";

    let payload = json!({
        "TimePeriod": "",
        "Metric": "",
        "Granularity": "",
        "Filter": "",
        "PredictionIntervalLevel": ""
    });

    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=AWSInsightsIndexService.GetCostForecast' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "TimePeriod": "",
  "Metric": "",
  "Granularity": "",
  "Filter": "",
  "PredictionIntervalLevel": ""
}'

echo '{
  "TimePeriod": "",
  "Metric": "",
  "Granularity": "",
  "Filter": "",
  "PredictionIntervalLevel": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostForecast' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TimePeriod": "",\n  "Metric": "",\n  "Granularity": "",\n  "Filter": "",\n  "PredictionIntervalLevel": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetCostForecast'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TimePeriod": "",
  "Metric": "",
  "Granularity": "",
  "Filter": "",
  "PredictionIntervalLevel": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetDimensionValues

HEADERS

X-Amz-Target

BODY json

{
  "SearchString": "",
  "TimePeriod": "",
  "Dimension": "",
  "Context": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "SortBy": "",
  "MaxResults": "",
  "NextPageToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"Dimension\": \"\",\n  \"Context\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetDimensionValues" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:SearchString ""
                                                                                                                   :TimePeriod ""
                                                                                                                   :Dimension ""
                                                                                                                   :Context ""
                                                                                                                   :Filter {:Or ""
                                                                                                                            :And ""
                                                                                                                            :Not ""
                                                                                                                            :Dimensions ""
                                                                                                                            :Tags ""
                                                                                                                            :CostCategories ""}
                                                                                                                   :SortBy ""
                                                                                                                   :MaxResults ""
                                                                                                                   :NextPageToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetDimensionValues"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"Dimension\": \"\",\n  \"Context\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetDimensionValues"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"Dimension\": \"\",\n  \"Context\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetDimensionValues");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"Dimension\": \"\",\n  \"Context\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetDimensionValues"

	payload := strings.NewReader("{\n  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"Dimension\": \"\",\n  \"Context\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\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: 265

{
  "SearchString": "",
  "TimePeriod": "",
  "Dimension": "",
  "Context": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "SortBy": "",
  "MaxResults": "",
  "NextPageToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetDimensionValues")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"Dimension\": \"\",\n  \"Context\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetDimensionValues"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"Dimension\": \"\",\n  \"Context\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\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  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"Dimension\": \"\",\n  \"Context\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetDimensionValues")
  .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=AWSInsightsIndexService.GetDimensionValues")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"Dimension\": \"\",\n  \"Context\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  SearchString: '',
  TimePeriod: '',
  Dimension: '',
  Context: '',
  Filter: {
    Or: '',
    And: '',
    Not: '',
    Dimensions: '',
    Tags: '',
    CostCategories: ''
  },
  SortBy: '',
  MaxResults: '',
  NextPageToken: ''
});

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=AWSInsightsIndexService.GetDimensionValues');
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=AWSInsightsIndexService.GetDimensionValues',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    SearchString: '',
    TimePeriod: '',
    Dimension: '',
    Context: '',
    Filter: {Or: '', And: '', Not: '', Dimensions: '', Tags: '', CostCategories: ''},
    SortBy: '',
    MaxResults: '',
    NextPageToken: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetDimensionValues';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SearchString":"","TimePeriod":"","Dimension":"","Context":"","Filter":{"Or":"","And":"","Not":"","Dimensions":"","Tags":"","CostCategories":""},"SortBy":"","MaxResults":"","NextPageToken":""}'
};

try {
  const response = await 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=AWSInsightsIndexService.GetDimensionValues',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SearchString": "",\n  "TimePeriod": "",\n  "Dimension": "",\n  "Context": "",\n  "Filter": {\n    "Or": "",\n    "And": "",\n    "Not": "",\n    "Dimensions": "",\n    "Tags": "",\n    "CostCategories": ""\n  },\n  "SortBy": "",\n  "MaxResults": "",\n  "NextPageToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"Dimension\": \"\",\n  \"Context\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetDimensionValues")
  .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({
  SearchString: '',
  TimePeriod: '',
  Dimension: '',
  Context: '',
  Filter: {Or: '', And: '', Not: '', Dimensions: '', Tags: '', CostCategories: ''},
  SortBy: '',
  MaxResults: '',
  NextPageToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetDimensionValues',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    SearchString: '',
    TimePeriod: '',
    Dimension: '',
    Context: '',
    Filter: {Or: '', And: '', Not: '', Dimensions: '', Tags: '', CostCategories: ''},
    SortBy: '',
    MaxResults: '',
    NextPageToken: ''
  },
  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=AWSInsightsIndexService.GetDimensionValues');

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

req.type('json');
req.send({
  SearchString: '',
  TimePeriod: '',
  Dimension: '',
  Context: '',
  Filter: {
    Or: '',
    And: '',
    Not: '',
    Dimensions: '',
    Tags: '',
    CostCategories: ''
  },
  SortBy: '',
  MaxResults: '',
  NextPageToken: ''
});

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=AWSInsightsIndexService.GetDimensionValues',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    SearchString: '',
    TimePeriod: '',
    Dimension: '',
    Context: '',
    Filter: {Or: '', And: '', Not: '', Dimensions: '', Tags: '', CostCategories: ''},
    SortBy: '',
    MaxResults: '',
    NextPageToken: ''
  }
};

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=AWSInsightsIndexService.GetDimensionValues';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SearchString":"","TimePeriod":"","Dimension":"","Context":"","Filter":{"Or":"","And":"","Not":"","Dimensions":"","Tags":"","CostCategories":""},"SortBy":"","MaxResults":"","NextPageToken":""}'
};

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 = @{ @"SearchString": @"",
                              @"TimePeriod": @"",
                              @"Dimension": @"",
                              @"Context": @"",
                              @"Filter": @{ @"Or": @"", @"And": @"", @"Not": @"", @"Dimensions": @"", @"Tags": @"", @"CostCategories": @"" },
                              @"SortBy": @"",
                              @"MaxResults": @"",
                              @"NextPageToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetDimensionValues"]
                                                       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=AWSInsightsIndexService.GetDimensionValues" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"Dimension\": \"\",\n  \"Context\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetDimensionValues",
  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([
    'SearchString' => '',
    'TimePeriod' => '',
    'Dimension' => '',
    'Context' => '',
    'Filter' => [
        'Or' => '',
        'And' => '',
        'Not' => '',
        'Dimensions' => '',
        'Tags' => '',
        'CostCategories' => ''
    ],
    'SortBy' => '',
    'MaxResults' => '',
    'NextPageToken' => ''
  ]),
  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=AWSInsightsIndexService.GetDimensionValues', [
  'body' => '{
  "SearchString": "",
  "TimePeriod": "",
  "Dimension": "",
  "Context": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "SortBy": "",
  "MaxResults": "",
  "NextPageToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'SearchString' => '',
  'TimePeriod' => '',
  'Dimension' => '',
  'Context' => '',
  'Filter' => [
    'Or' => '',
    'And' => '',
    'Not' => '',
    'Dimensions' => '',
    'Tags' => '',
    'CostCategories' => ''
  ],
  'SortBy' => '',
  'MaxResults' => '',
  'NextPageToken' => ''
]));

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

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

append(json_encode([
  'SearchString' => '',
  'TimePeriod' => '',
  'Dimension' => '',
  'Context' => '',
  'Filter' => [
    'Or' => '',
    'And' => '',
    'Not' => '',
    'Dimensions' => '',
    'Tags' => '',
    'CostCategories' => ''
  ],
  'SortBy' => '',
  'MaxResults' => '',
  'NextPageToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetDimensionValues');
$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=AWSInsightsIndexService.GetDimensionValues' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SearchString": "",
  "TimePeriod": "",
  "Dimension": "",
  "Context": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "SortBy": "",
  "MaxResults": "",
  "NextPageToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetDimensionValues' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SearchString": "",
  "TimePeriod": "",
  "Dimension": "",
  "Context": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "SortBy": "",
  "MaxResults": "",
  "NextPageToken": ""
}'

import http.client

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

payload = "{\n  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"Dimension\": \"\",\n  \"Context\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetDimensionValues"

payload = {
    "SearchString": "",
    "TimePeriod": "",
    "Dimension": "",
    "Context": "",
    "Filter": {
        "Or": "",
        "And": "",
        "Not": "",
        "Dimensions": "",
        "Tags": "",
        "CostCategories": ""
    },
    "SortBy": "",
    "MaxResults": "",
    "NextPageToken": ""
}
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=AWSInsightsIndexService.GetDimensionValues"

payload <- "{\n  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"Dimension\": \"\",\n  \"Context\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetDimensionValues")

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  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"Dimension\": \"\",\n  \"Context\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\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  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"Dimension\": \"\",\n  \"Context\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetDimensionValues";

    let payload = json!({
        "SearchString": "",
        "TimePeriod": "",
        "Dimension": "",
        "Context": "",
        "Filter": json!({
            "Or": "",
            "And": "",
            "Not": "",
            "Dimensions": "",
            "Tags": "",
            "CostCategories": ""
        }),
        "SortBy": "",
        "MaxResults": "",
        "NextPageToken": ""
    });

    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=AWSInsightsIndexService.GetDimensionValues' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "SearchString": "",
  "TimePeriod": "",
  "Dimension": "",
  "Context": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "SortBy": "",
  "MaxResults": "",
  "NextPageToken": ""
}'

echo '{
  "SearchString": "",
  "TimePeriod": "",
  "Dimension": "",
  "Context": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "SortBy": "",
  "MaxResults": "",
  "NextPageToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetDimensionValues' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "SearchString": "",\n  "TimePeriod": "",\n  "Dimension": "",\n  "Context": "",\n  "Filter": {\n    "Or": "",\n    "And": "",\n    "Not": "",\n    "Dimensions": "",\n    "Tags": "",\n    "CostCategories": ""\n  },\n  "SortBy": "",\n  "MaxResults": "",\n  "NextPageToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetDimensionValues'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "SearchString": "",
  "TimePeriod": "",
  "Dimension": "",
  "Context": "",
  "Filter": [
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  ],
  "SortBy": "",
  "MaxResults": "",
  "NextPageToken": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationCoverage

HEADERS

X-Amz-Target

BODY json

{
  "TimePeriod": "",
  "GroupBy": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "NextPageToken": "",
  "SortBy": "",
  "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=AWSInsightsIndexService.GetReservationCoverage");

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  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextPageToken\": \"\",\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationCoverage" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:TimePeriod ""
                                                                                                                       :GroupBy ""
                                                                                                                       :Granularity ""
                                                                                                                       :Filter ""
                                                                                                                       :Metrics ""
                                                                                                                       :NextPageToken ""
                                                                                                                       :SortBy ""
                                                                                                                       :MaxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationCoverage"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextPageToken\": \"\",\n  \"SortBy\": \"\",\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=AWSInsightsIndexService.GetReservationCoverage"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextPageToken\": \"\",\n  \"SortBy\": \"\",\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=AWSInsightsIndexService.GetReservationCoverage");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextPageToken\": \"\",\n  \"SortBy\": \"\",\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=AWSInsightsIndexService.GetReservationCoverage"

	payload := strings.NewReader("{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextPageToken\": \"\",\n  \"SortBy\": \"\",\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: 152

{
  "TimePeriod": "",
  "GroupBy": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "NextPageToken": "",
  "SortBy": "",
  "MaxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationCoverage")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextPageToken\": \"\",\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationCoverage"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextPageToken\": \"\",\n  \"SortBy\": \"\",\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  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextPageToken\": \"\",\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationCoverage")
  .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=AWSInsightsIndexService.GetReservationCoverage")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextPageToken\": \"\",\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TimePeriod: '',
  GroupBy: '',
  Granularity: '',
  Filter: '',
  Metrics: '',
  NextPageToken: '',
  SortBy: '',
  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=AWSInsightsIndexService.GetReservationCoverage');
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=AWSInsightsIndexService.GetReservationCoverage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TimePeriod: '',
    GroupBy: '',
    Granularity: '',
    Filter: '',
    Metrics: '',
    NextPageToken: '',
    SortBy: '',
    MaxResults: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationCoverage';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TimePeriod":"","GroupBy":"","Granularity":"","Filter":"","Metrics":"","NextPageToken":"","SortBy":"","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=AWSInsightsIndexService.GetReservationCoverage',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TimePeriod": "",\n  "GroupBy": "",\n  "Granularity": "",\n  "Filter": "",\n  "Metrics": "",\n  "NextPageToken": "",\n  "SortBy": "",\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  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextPageToken\": \"\",\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationCoverage")
  .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({
  TimePeriod: '',
  GroupBy: '',
  Granularity: '',
  Filter: '',
  Metrics: '',
  NextPageToken: '',
  SortBy: '',
  MaxResults: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationCoverage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    TimePeriod: '',
    GroupBy: '',
    Granularity: '',
    Filter: '',
    Metrics: '',
    NextPageToken: '',
    SortBy: '',
    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=AWSInsightsIndexService.GetReservationCoverage');

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

req.type('json');
req.send({
  TimePeriod: '',
  GroupBy: '',
  Granularity: '',
  Filter: '',
  Metrics: '',
  NextPageToken: '',
  SortBy: '',
  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=AWSInsightsIndexService.GetReservationCoverage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TimePeriod: '',
    GroupBy: '',
    Granularity: '',
    Filter: '',
    Metrics: '',
    NextPageToken: '',
    SortBy: '',
    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=AWSInsightsIndexService.GetReservationCoverage';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TimePeriod":"","GroupBy":"","Granularity":"","Filter":"","Metrics":"","NextPageToken":"","SortBy":"","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 = @{ @"TimePeriod": @"",
                              @"GroupBy": @"",
                              @"Granularity": @"",
                              @"Filter": @"",
                              @"Metrics": @"",
                              @"NextPageToken": @"",
                              @"SortBy": @"",
                              @"MaxResults": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationCoverage"]
                                                       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=AWSInsightsIndexService.GetReservationCoverage" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextPageToken\": \"\",\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationCoverage",
  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([
    'TimePeriod' => '',
    'GroupBy' => '',
    'Granularity' => '',
    'Filter' => '',
    'Metrics' => '',
    'NextPageToken' => '',
    'SortBy' => '',
    '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=AWSInsightsIndexService.GetReservationCoverage', [
  'body' => '{
  "TimePeriod": "",
  "GroupBy": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "NextPageToken": "",
  "SortBy": "",
  "MaxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TimePeriod' => '',
  'GroupBy' => '',
  'Granularity' => '',
  'Filter' => '',
  'Metrics' => '',
  'NextPageToken' => '',
  'SortBy' => '',
  'MaxResults' => ''
]));

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

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

append(json_encode([
  'TimePeriod' => '',
  'GroupBy' => '',
  'Granularity' => '',
  'Filter' => '',
  'Metrics' => '',
  'NextPageToken' => '',
  'SortBy' => '',
  'MaxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationCoverage');
$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=AWSInsightsIndexService.GetReservationCoverage' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TimePeriod": "",
  "GroupBy": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "NextPageToken": "",
  "SortBy": "",
  "MaxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationCoverage' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TimePeriod": "",
  "GroupBy": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "NextPageToken": "",
  "SortBy": "",
  "MaxResults": ""
}'

import http.client

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

payload = "{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextPageToken\": \"\",\n  \"SortBy\": \"\",\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=AWSInsightsIndexService.GetReservationCoverage"

payload = {
    "TimePeriod": "",
    "GroupBy": "",
    "Granularity": "",
    "Filter": "",
    "Metrics": "",
    "NextPageToken": "",
    "SortBy": "",
    "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=AWSInsightsIndexService.GetReservationCoverage"

payload <- "{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextPageToken\": \"\",\n  \"SortBy\": \"\",\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=AWSInsightsIndexService.GetReservationCoverage")

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  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextPageToken\": \"\",\n  \"SortBy\": \"\",\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  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextPageToken\": \"\",\n  \"SortBy\": \"\",\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=AWSInsightsIndexService.GetReservationCoverage";

    let payload = json!({
        "TimePeriod": "",
        "GroupBy": "",
        "Granularity": "",
        "Filter": "",
        "Metrics": "",
        "NextPageToken": "",
        "SortBy": "",
        "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=AWSInsightsIndexService.GetReservationCoverage' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "TimePeriod": "",
  "GroupBy": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "NextPageToken": "",
  "SortBy": "",
  "MaxResults": ""
}'

echo '{
  "TimePeriod": "",
  "GroupBy": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "NextPageToken": "",
  "SortBy": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationCoverage' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TimePeriod": "",\n  "GroupBy": "",\n  "Granularity": "",\n  "Filter": "",\n  "Metrics": "",\n  "NextPageToken": "",\n  "SortBy": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationCoverage'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TimePeriod": "",
  "GroupBy": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "NextPageToken": "",
  "SortBy": "",
  "MaxResults": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationPurchaseRecommendation

HEADERS

X-Amz-Target

BODY json

{
  "AccountId": "",
  "Service": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "AccountScope": "",
  "LookbackPeriodInDays": "",
  "TermInYears": "",
  "PaymentOption": "",
  "ServiceSpecification": "",
  "PageSize": "",
  "NextPageToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"AccountId\": \"\",\n  \"Service\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"AccountScope\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"ServiceSpecification\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationPurchaseRecommendation" {:headers {:x-amz-target ""}
                                                                                                                       :content-type :json
                                                                                                                       :form-params {:AccountId ""
                                                                                                                                     :Service ""
                                                                                                                                     :Filter {:Or ""
                                                                                                                                              :And ""
                                                                                                                                              :Not ""
                                                                                                                                              :Dimensions ""
                                                                                                                                              :Tags ""
                                                                                                                                              :CostCategories ""}
                                                                                                                                     :AccountScope ""
                                                                                                                                     :LookbackPeriodInDays ""
                                                                                                                                     :TermInYears ""
                                                                                                                                     :PaymentOption ""
                                                                                                                                     :ServiceSpecification ""
                                                                                                                                     :PageSize ""
                                                                                                                                     :NextPageToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationPurchaseRecommendation"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"AccountId\": \"\",\n  \"Service\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"AccountScope\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"ServiceSpecification\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetReservationPurchaseRecommendation"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"AccountId\": \"\",\n  \"Service\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"AccountScope\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"ServiceSpecification\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetReservationPurchaseRecommendation");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"AccountId\": \"\",\n  \"Service\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"AccountScope\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"ServiceSpecification\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationPurchaseRecommendation"

	payload := strings.NewReader("{\n  \"AccountId\": \"\",\n  \"Service\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"AccountScope\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"ServiceSpecification\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\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: 331

{
  "AccountId": "",
  "Service": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "AccountScope": "",
  "LookbackPeriodInDays": "",
  "TermInYears": "",
  "PaymentOption": "",
  "ServiceSpecification": "",
  "PageSize": "",
  "NextPageToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationPurchaseRecommendation")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"AccountId\": \"\",\n  \"Service\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"AccountScope\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"ServiceSpecification\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationPurchaseRecommendation"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"AccountId\": \"\",\n  \"Service\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"AccountScope\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"ServiceSpecification\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\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  \"AccountId\": \"\",\n  \"Service\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"AccountScope\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"ServiceSpecification\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationPurchaseRecommendation")
  .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=AWSInsightsIndexService.GetReservationPurchaseRecommendation")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"AccountId\": \"\",\n  \"Service\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"AccountScope\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"ServiceSpecification\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  AccountId: '',
  Service: '',
  Filter: {
    Or: '',
    And: '',
    Not: '',
    Dimensions: '',
    Tags: '',
    CostCategories: ''
  },
  AccountScope: '',
  LookbackPeriodInDays: '',
  TermInYears: '',
  PaymentOption: '',
  ServiceSpecification: '',
  PageSize: '',
  NextPageToken: ''
});

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=AWSInsightsIndexService.GetReservationPurchaseRecommendation');
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=AWSInsightsIndexService.GetReservationPurchaseRecommendation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AccountId: '',
    Service: '',
    Filter: {Or: '', And: '', Not: '', Dimensions: '', Tags: '', CostCategories: ''},
    AccountScope: '',
    LookbackPeriodInDays: '',
    TermInYears: '',
    PaymentOption: '',
    ServiceSpecification: '',
    PageSize: '',
    NextPageToken: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationPurchaseRecommendation';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AccountId":"","Service":"","Filter":{"Or":"","And":"","Not":"","Dimensions":"","Tags":"","CostCategories":""},"AccountScope":"","LookbackPeriodInDays":"","TermInYears":"","PaymentOption":"","ServiceSpecification":"","PageSize":"","NextPageToken":""}'
};

try {
  const response = await 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=AWSInsightsIndexService.GetReservationPurchaseRecommendation',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AccountId": "",\n  "Service": "",\n  "Filter": {\n    "Or": "",\n    "And": "",\n    "Not": "",\n    "Dimensions": "",\n    "Tags": "",\n    "CostCategories": ""\n  },\n  "AccountScope": "",\n  "LookbackPeriodInDays": "",\n  "TermInYears": "",\n  "PaymentOption": "",\n  "ServiceSpecification": "",\n  "PageSize": "",\n  "NextPageToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AccountId\": \"\",\n  \"Service\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"AccountScope\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"ServiceSpecification\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationPurchaseRecommendation")
  .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({
  AccountId: '',
  Service: '',
  Filter: {Or: '', And: '', Not: '', Dimensions: '', Tags: '', CostCategories: ''},
  AccountScope: '',
  LookbackPeriodInDays: '',
  TermInYears: '',
  PaymentOption: '',
  ServiceSpecification: '',
  PageSize: '',
  NextPageToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationPurchaseRecommendation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    AccountId: '',
    Service: '',
    Filter: {Or: '', And: '', Not: '', Dimensions: '', Tags: '', CostCategories: ''},
    AccountScope: '',
    LookbackPeriodInDays: '',
    TermInYears: '',
    PaymentOption: '',
    ServiceSpecification: '',
    PageSize: '',
    NextPageToken: ''
  },
  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=AWSInsightsIndexService.GetReservationPurchaseRecommendation');

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

req.type('json');
req.send({
  AccountId: '',
  Service: '',
  Filter: {
    Or: '',
    And: '',
    Not: '',
    Dimensions: '',
    Tags: '',
    CostCategories: ''
  },
  AccountScope: '',
  LookbackPeriodInDays: '',
  TermInYears: '',
  PaymentOption: '',
  ServiceSpecification: '',
  PageSize: '',
  NextPageToken: ''
});

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=AWSInsightsIndexService.GetReservationPurchaseRecommendation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    AccountId: '',
    Service: '',
    Filter: {Or: '', And: '', Not: '', Dimensions: '', Tags: '', CostCategories: ''},
    AccountScope: '',
    LookbackPeriodInDays: '',
    TermInYears: '',
    PaymentOption: '',
    ServiceSpecification: '',
    PageSize: '',
    NextPageToken: ''
  }
};

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=AWSInsightsIndexService.GetReservationPurchaseRecommendation';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AccountId":"","Service":"","Filter":{"Or":"","And":"","Not":"","Dimensions":"","Tags":"","CostCategories":""},"AccountScope":"","LookbackPeriodInDays":"","TermInYears":"","PaymentOption":"","ServiceSpecification":"","PageSize":"","NextPageToken":""}'
};

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 = @{ @"AccountId": @"",
                              @"Service": @"",
                              @"Filter": @{ @"Or": @"", @"And": @"", @"Not": @"", @"Dimensions": @"", @"Tags": @"", @"CostCategories": @"" },
                              @"AccountScope": @"",
                              @"LookbackPeriodInDays": @"",
                              @"TermInYears": @"",
                              @"PaymentOption": @"",
                              @"ServiceSpecification": @"",
                              @"PageSize": @"",
                              @"NextPageToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationPurchaseRecommendation"]
                                                       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=AWSInsightsIndexService.GetReservationPurchaseRecommendation" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"AccountId\": \"\",\n  \"Service\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"AccountScope\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"ServiceSpecification\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationPurchaseRecommendation",
  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([
    'AccountId' => '',
    'Service' => '',
    'Filter' => [
        'Or' => '',
        'And' => '',
        'Not' => '',
        'Dimensions' => '',
        'Tags' => '',
        'CostCategories' => ''
    ],
    'AccountScope' => '',
    'LookbackPeriodInDays' => '',
    'TermInYears' => '',
    'PaymentOption' => '',
    'ServiceSpecification' => '',
    'PageSize' => '',
    'NextPageToken' => ''
  ]),
  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=AWSInsightsIndexService.GetReservationPurchaseRecommendation', [
  'body' => '{
  "AccountId": "",
  "Service": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "AccountScope": "",
  "LookbackPeriodInDays": "",
  "TermInYears": "",
  "PaymentOption": "",
  "ServiceSpecification": "",
  "PageSize": "",
  "NextPageToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'AccountId' => '',
  'Service' => '',
  'Filter' => [
    'Or' => '',
    'And' => '',
    'Not' => '',
    'Dimensions' => '',
    'Tags' => '',
    'CostCategories' => ''
  ],
  'AccountScope' => '',
  'LookbackPeriodInDays' => '',
  'TermInYears' => '',
  'PaymentOption' => '',
  'ServiceSpecification' => '',
  'PageSize' => '',
  'NextPageToken' => ''
]));

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

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

append(json_encode([
  'AccountId' => '',
  'Service' => '',
  'Filter' => [
    'Or' => '',
    'And' => '',
    'Not' => '',
    'Dimensions' => '',
    'Tags' => '',
    'CostCategories' => ''
  ],
  'AccountScope' => '',
  'LookbackPeriodInDays' => '',
  'TermInYears' => '',
  'PaymentOption' => '',
  'ServiceSpecification' => '',
  'PageSize' => '',
  'NextPageToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationPurchaseRecommendation');
$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=AWSInsightsIndexService.GetReservationPurchaseRecommendation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccountId": "",
  "Service": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "AccountScope": "",
  "LookbackPeriodInDays": "",
  "TermInYears": "",
  "PaymentOption": "",
  "ServiceSpecification": "",
  "PageSize": "",
  "NextPageToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationPurchaseRecommendation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AccountId": "",
  "Service": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "AccountScope": "",
  "LookbackPeriodInDays": "",
  "TermInYears": "",
  "PaymentOption": "",
  "ServiceSpecification": "",
  "PageSize": "",
  "NextPageToken": ""
}'

import http.client

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

payload = "{\n  \"AccountId\": \"\",\n  \"Service\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"AccountScope\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"ServiceSpecification\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetReservationPurchaseRecommendation"

payload = {
    "AccountId": "",
    "Service": "",
    "Filter": {
        "Or": "",
        "And": "",
        "Not": "",
        "Dimensions": "",
        "Tags": "",
        "CostCategories": ""
    },
    "AccountScope": "",
    "LookbackPeriodInDays": "",
    "TermInYears": "",
    "PaymentOption": "",
    "ServiceSpecification": "",
    "PageSize": "",
    "NextPageToken": ""
}
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=AWSInsightsIndexService.GetReservationPurchaseRecommendation"

payload <- "{\n  \"AccountId\": \"\",\n  \"Service\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"AccountScope\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"ServiceSpecification\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetReservationPurchaseRecommendation")

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  \"AccountId\": \"\",\n  \"Service\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"AccountScope\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"ServiceSpecification\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\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  \"AccountId\": \"\",\n  \"Service\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"AccountScope\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"ServiceSpecification\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetReservationPurchaseRecommendation";

    let payload = json!({
        "AccountId": "",
        "Service": "",
        "Filter": json!({
            "Or": "",
            "And": "",
            "Not": "",
            "Dimensions": "",
            "Tags": "",
            "CostCategories": ""
        }),
        "AccountScope": "",
        "LookbackPeriodInDays": "",
        "TermInYears": "",
        "PaymentOption": "",
        "ServiceSpecification": "",
        "PageSize": "",
        "NextPageToken": ""
    });

    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=AWSInsightsIndexService.GetReservationPurchaseRecommendation' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AccountId": "",
  "Service": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "AccountScope": "",
  "LookbackPeriodInDays": "",
  "TermInYears": "",
  "PaymentOption": "",
  "ServiceSpecification": "",
  "PageSize": "",
  "NextPageToken": ""
}'

echo '{
  "AccountId": "",
  "Service": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "AccountScope": "",
  "LookbackPeriodInDays": "",
  "TermInYears": "",
  "PaymentOption": "",
  "ServiceSpecification": "",
  "PageSize": "",
  "NextPageToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationPurchaseRecommendation' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "AccountId": "",\n  "Service": "",\n  "Filter": {\n    "Or": "",\n    "And": "",\n    "Not": "",\n    "Dimensions": "",\n    "Tags": "",\n    "CostCategories": ""\n  },\n  "AccountScope": "",\n  "LookbackPeriodInDays": "",\n  "TermInYears": "",\n  "PaymentOption": "",\n  "ServiceSpecification": "",\n  "PageSize": "",\n  "NextPageToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationPurchaseRecommendation'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "AccountId": "",
  "Service": "",
  "Filter": [
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  ],
  "AccountScope": "",
  "LookbackPeriodInDays": "",
  "TermInYears": "",
  "PaymentOption": "",
  "ServiceSpecification": "",
  "PageSize": "",
  "NextPageToken": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationUtilization

HEADERS

X-Amz-Target

BODY json

{
  "TimePeriod": "",
  "GroupBy": "",
  "Granularity": "",
  "Filter": "",
  "SortBy": "",
  "NextPageToken": "",
  "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=AWSInsightsIndexService.GetReservationUtilization");

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  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"SortBy\": \"\",\n  \"NextPageToken\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationUtilization" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:TimePeriod ""
                                                                                                                          :GroupBy ""
                                                                                                                          :Granularity ""
                                                                                                                          :Filter ""
                                                                                                                          :SortBy ""
                                                                                                                          :NextPageToken ""
                                                                                                                          :MaxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationUtilization"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"SortBy\": \"\",\n  \"NextPageToken\": \"\",\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=AWSInsightsIndexService.GetReservationUtilization"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"SortBy\": \"\",\n  \"NextPageToken\": \"\",\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=AWSInsightsIndexService.GetReservationUtilization");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"SortBy\": \"\",\n  \"NextPageToken\": \"\",\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=AWSInsightsIndexService.GetReservationUtilization"

	payload := strings.NewReader("{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"SortBy\": \"\",\n  \"NextPageToken\": \"\",\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: 135

{
  "TimePeriod": "",
  "GroupBy": "",
  "Granularity": "",
  "Filter": "",
  "SortBy": "",
  "NextPageToken": "",
  "MaxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationUtilization")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"SortBy\": \"\",\n  \"NextPageToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationUtilization"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"SortBy\": \"\",\n  \"NextPageToken\": \"\",\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  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"SortBy\": \"\",\n  \"NextPageToken\": \"\",\n  \"MaxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationUtilization")
  .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=AWSInsightsIndexService.GetReservationUtilization")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"SortBy\": \"\",\n  \"NextPageToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TimePeriod: '',
  GroupBy: '',
  Granularity: '',
  Filter: '',
  SortBy: '',
  NextPageToken: '',
  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=AWSInsightsIndexService.GetReservationUtilization');
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=AWSInsightsIndexService.GetReservationUtilization',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TimePeriod: '',
    GroupBy: '',
    Granularity: '',
    Filter: '',
    SortBy: '',
    NextPageToken: '',
    MaxResults: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationUtilization';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TimePeriod":"","GroupBy":"","Granularity":"","Filter":"","SortBy":"","NextPageToken":"","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=AWSInsightsIndexService.GetReservationUtilization',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TimePeriod": "",\n  "GroupBy": "",\n  "Granularity": "",\n  "Filter": "",\n  "SortBy": "",\n  "NextPageToken": "",\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  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"SortBy\": \"\",\n  \"NextPageToken\": \"\",\n  \"MaxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationUtilization")
  .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({
  TimePeriod: '',
  GroupBy: '',
  Granularity: '',
  Filter: '',
  SortBy: '',
  NextPageToken: '',
  MaxResults: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationUtilization',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    TimePeriod: '',
    GroupBy: '',
    Granularity: '',
    Filter: '',
    SortBy: '',
    NextPageToken: '',
    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=AWSInsightsIndexService.GetReservationUtilization');

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

req.type('json');
req.send({
  TimePeriod: '',
  GroupBy: '',
  Granularity: '',
  Filter: '',
  SortBy: '',
  NextPageToken: '',
  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=AWSInsightsIndexService.GetReservationUtilization',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TimePeriod: '',
    GroupBy: '',
    Granularity: '',
    Filter: '',
    SortBy: '',
    NextPageToken: '',
    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=AWSInsightsIndexService.GetReservationUtilization';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TimePeriod":"","GroupBy":"","Granularity":"","Filter":"","SortBy":"","NextPageToken":"","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 = @{ @"TimePeriod": @"",
                              @"GroupBy": @"",
                              @"Granularity": @"",
                              @"Filter": @"",
                              @"SortBy": @"",
                              @"NextPageToken": @"",
                              @"MaxResults": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationUtilization"]
                                                       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=AWSInsightsIndexService.GetReservationUtilization" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"SortBy\": \"\",\n  \"NextPageToken\": \"\",\n  \"MaxResults\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationUtilization",
  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([
    'TimePeriod' => '',
    'GroupBy' => '',
    'Granularity' => '',
    'Filter' => '',
    'SortBy' => '',
    'NextPageToken' => '',
    '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=AWSInsightsIndexService.GetReservationUtilization', [
  'body' => '{
  "TimePeriod": "",
  "GroupBy": "",
  "Granularity": "",
  "Filter": "",
  "SortBy": "",
  "NextPageToken": "",
  "MaxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TimePeriod' => '',
  'GroupBy' => '',
  'Granularity' => '',
  'Filter' => '',
  'SortBy' => '',
  'NextPageToken' => '',
  'MaxResults' => ''
]));

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

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

append(json_encode([
  'TimePeriod' => '',
  'GroupBy' => '',
  'Granularity' => '',
  'Filter' => '',
  'SortBy' => '',
  'NextPageToken' => '',
  'MaxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationUtilization');
$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=AWSInsightsIndexService.GetReservationUtilization' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TimePeriod": "",
  "GroupBy": "",
  "Granularity": "",
  "Filter": "",
  "SortBy": "",
  "NextPageToken": "",
  "MaxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationUtilization' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TimePeriod": "",
  "GroupBy": "",
  "Granularity": "",
  "Filter": "",
  "SortBy": "",
  "NextPageToken": "",
  "MaxResults": ""
}'

import http.client

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

payload = "{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"SortBy\": \"\",\n  \"NextPageToken\": \"\",\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=AWSInsightsIndexService.GetReservationUtilization"

payload = {
    "TimePeriod": "",
    "GroupBy": "",
    "Granularity": "",
    "Filter": "",
    "SortBy": "",
    "NextPageToken": "",
    "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=AWSInsightsIndexService.GetReservationUtilization"

payload <- "{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"SortBy\": \"\",\n  \"NextPageToken\": \"\",\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=AWSInsightsIndexService.GetReservationUtilization")

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  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"SortBy\": \"\",\n  \"NextPageToken\": \"\",\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  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"SortBy\": \"\",\n  \"NextPageToken\": \"\",\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=AWSInsightsIndexService.GetReservationUtilization";

    let payload = json!({
        "TimePeriod": "",
        "GroupBy": "",
        "Granularity": "",
        "Filter": "",
        "SortBy": "",
        "NextPageToken": "",
        "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=AWSInsightsIndexService.GetReservationUtilization' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "TimePeriod": "",
  "GroupBy": "",
  "Granularity": "",
  "Filter": "",
  "SortBy": "",
  "NextPageToken": "",
  "MaxResults": ""
}'

echo '{
  "TimePeriod": "",
  "GroupBy": "",
  "Granularity": "",
  "Filter": "",
  "SortBy": "",
  "NextPageToken": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationUtilization' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TimePeriod": "",\n  "GroupBy": "",\n  "Granularity": "",\n  "Filter": "",\n  "SortBy": "",\n  "NextPageToken": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetReservationUtilization'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TimePeriod": "",
  "GroupBy": "",
  "Granularity": "",
  "Filter": "",
  "SortBy": "",
  "NextPageToken": "",
  "MaxResults": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetRightsizingRecommendation

HEADERS

X-Amz-Target

BODY json

{
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "Configuration": "",
  "Service": "",
  "PageSize": "",
  "NextPageToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"Configuration\": \"\",\n  \"Service\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetRightsizingRecommendation" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:Filter {:Or ""
                                                                                                                                      :And ""
                                                                                                                                      :Not ""
                                                                                                                                      :Dimensions ""
                                                                                                                                      :Tags ""
                                                                                                                                      :CostCategories ""}
                                                                                                                             :Configuration ""
                                                                                                                             :Service ""
                                                                                                                             :PageSize ""
                                                                                                                             :NextPageToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetRightsizingRecommendation"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"Configuration\": \"\",\n  \"Service\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetRightsizingRecommendation"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"Configuration\": \"\",\n  \"Service\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetRightsizingRecommendation");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"Configuration\": \"\",\n  \"Service\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetRightsizingRecommendation"

	payload := strings.NewReader("{\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"Configuration\": \"\",\n  \"Service\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\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: 209

{
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "Configuration": "",
  "Service": "",
  "PageSize": "",
  "NextPageToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetRightsizingRecommendation")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"Configuration\": \"\",\n  \"Service\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetRightsizingRecommendation"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"Configuration\": \"\",\n  \"Service\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\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  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"Configuration\": \"\",\n  \"Service\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetRightsizingRecommendation")
  .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=AWSInsightsIndexService.GetRightsizingRecommendation")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"Configuration\": \"\",\n  \"Service\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Filter: {
    Or: '',
    And: '',
    Not: '',
    Dimensions: '',
    Tags: '',
    CostCategories: ''
  },
  Configuration: '',
  Service: '',
  PageSize: '',
  NextPageToken: ''
});

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=AWSInsightsIndexService.GetRightsizingRecommendation');
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=AWSInsightsIndexService.GetRightsizingRecommendation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Filter: {Or: '', And: '', Not: '', Dimensions: '', Tags: '', CostCategories: ''},
    Configuration: '',
    Service: '',
    PageSize: '',
    NextPageToken: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetRightsizingRecommendation';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filter":{"Or":"","And":"","Not":"","Dimensions":"","Tags":"","CostCategories":""},"Configuration":"","Service":"","PageSize":"","NextPageToken":""}'
};

try {
  const response = await 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=AWSInsightsIndexService.GetRightsizingRecommendation',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Filter": {\n    "Or": "",\n    "And": "",\n    "Not": "",\n    "Dimensions": "",\n    "Tags": "",\n    "CostCategories": ""\n  },\n  "Configuration": "",\n  "Service": "",\n  "PageSize": "",\n  "NextPageToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"Configuration\": \"\",\n  \"Service\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetRightsizingRecommendation")
  .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({
  Filter: {Or: '', And: '', Not: '', Dimensions: '', Tags: '', CostCategories: ''},
  Configuration: '',
  Service: '',
  PageSize: '',
  NextPageToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetRightsizingRecommendation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    Filter: {Or: '', And: '', Not: '', Dimensions: '', Tags: '', CostCategories: ''},
    Configuration: '',
    Service: '',
    PageSize: '',
    NextPageToken: ''
  },
  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=AWSInsightsIndexService.GetRightsizingRecommendation');

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

req.type('json');
req.send({
  Filter: {
    Or: '',
    And: '',
    Not: '',
    Dimensions: '',
    Tags: '',
    CostCategories: ''
  },
  Configuration: '',
  Service: '',
  PageSize: '',
  NextPageToken: ''
});

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=AWSInsightsIndexService.GetRightsizingRecommendation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    Filter: {Or: '', And: '', Not: '', Dimensions: '', Tags: '', CostCategories: ''},
    Configuration: '',
    Service: '',
    PageSize: '',
    NextPageToken: ''
  }
};

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=AWSInsightsIndexService.GetRightsizingRecommendation';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Filter":{"Or":"","And":"","Not":"","Dimensions":"","Tags":"","CostCategories":""},"Configuration":"","Service":"","PageSize":"","NextPageToken":""}'
};

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 = @{ @"Filter": @{ @"Or": @"", @"And": @"", @"Not": @"", @"Dimensions": @"", @"Tags": @"", @"CostCategories": @"" },
                              @"Configuration": @"",
                              @"Service": @"",
                              @"PageSize": @"",
                              @"NextPageToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetRightsizingRecommendation"]
                                                       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=AWSInsightsIndexService.GetRightsizingRecommendation" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"Configuration\": \"\",\n  \"Service\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetRightsizingRecommendation",
  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([
    'Filter' => [
        'Or' => '',
        'And' => '',
        'Not' => '',
        'Dimensions' => '',
        'Tags' => '',
        'CostCategories' => ''
    ],
    'Configuration' => '',
    'Service' => '',
    'PageSize' => '',
    'NextPageToken' => ''
  ]),
  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=AWSInsightsIndexService.GetRightsizingRecommendation', [
  'body' => '{
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "Configuration": "",
  "Service": "",
  "PageSize": "",
  "NextPageToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Filter' => [
    'Or' => '',
    'And' => '',
    'Not' => '',
    'Dimensions' => '',
    'Tags' => '',
    'CostCategories' => ''
  ],
  'Configuration' => '',
  'Service' => '',
  'PageSize' => '',
  'NextPageToken' => ''
]));

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

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

append(json_encode([
  'Filter' => [
    'Or' => '',
    'And' => '',
    'Not' => '',
    'Dimensions' => '',
    'Tags' => '',
    'CostCategories' => ''
  ],
  'Configuration' => '',
  'Service' => '',
  'PageSize' => '',
  'NextPageToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetRightsizingRecommendation');
$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=AWSInsightsIndexService.GetRightsizingRecommendation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "Configuration": "",
  "Service": "",
  "PageSize": "",
  "NextPageToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetRightsizingRecommendation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "Configuration": "",
  "Service": "",
  "PageSize": "",
  "NextPageToken": ""
}'

import http.client

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

payload = "{\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"Configuration\": \"\",\n  \"Service\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetRightsizingRecommendation"

payload = {
    "Filter": {
        "Or": "",
        "And": "",
        "Not": "",
        "Dimensions": "",
        "Tags": "",
        "CostCategories": ""
    },
    "Configuration": "",
    "Service": "",
    "PageSize": "",
    "NextPageToken": ""
}
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=AWSInsightsIndexService.GetRightsizingRecommendation"

payload <- "{\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"Configuration\": \"\",\n  \"Service\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetRightsizingRecommendation")

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  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"Configuration\": \"\",\n  \"Service\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\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  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"Configuration\": \"\",\n  \"Service\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetRightsizingRecommendation";

    let payload = json!({
        "Filter": json!({
            "Or": "",
            "And": "",
            "Not": "",
            "Dimensions": "",
            "Tags": "",
            "CostCategories": ""
        }),
        "Configuration": "",
        "Service": "",
        "PageSize": "",
        "NextPageToken": ""
    });

    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=AWSInsightsIndexService.GetRightsizingRecommendation' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "Configuration": "",
  "Service": "",
  "PageSize": "",
  "NextPageToken": ""
}'

echo '{
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "Configuration": "",
  "Service": "",
  "PageSize": "",
  "NextPageToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetRightsizingRecommendation' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Filter": {\n    "Or": "",\n    "And": "",\n    "Not": "",\n    "Dimensions": "",\n    "Tags": "",\n    "CostCategories": ""\n  },\n  "Configuration": "",\n  "Service": "",\n  "PageSize": "",\n  "NextPageToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetRightsizingRecommendation'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Filter": [
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  ],
  "Configuration": "",
  "Service": "",
  "PageSize": "",
  "NextPageToken": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansCoverage

HEADERS

X-Amz-Target

BODY json

{
  "TimePeriod": "",
  "GroupBy": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "NextToken": "",
  "MaxResults": "",
  "SortBy": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"SortBy\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansCoverage" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:TimePeriod ""
                                                                                                                        :GroupBy ""
                                                                                                                        :Granularity ""
                                                                                                                        :Filter ""
                                                                                                                        :Metrics ""
                                                                                                                        :NextToken ""
                                                                                                                        :MaxResults ""
                                                                                                                        :SortBy ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansCoverage"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"SortBy\": \"\"\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=AWSInsightsIndexService.GetSavingsPlansCoverage"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"SortBy\": \"\"\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=AWSInsightsIndexService.GetSavingsPlansCoverage");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"SortBy\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansCoverage"

	payload := strings.NewReader("{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"SortBy\": \"\"\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: 148

{
  "TimePeriod": "",
  "GroupBy": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "NextToken": "",
  "MaxResults": "",
  "SortBy": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansCoverage")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"SortBy\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansCoverage"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"SortBy\": \"\"\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  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"SortBy\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansCoverage")
  .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=AWSInsightsIndexService.GetSavingsPlansCoverage")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"SortBy\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TimePeriod: '',
  GroupBy: '',
  Granularity: '',
  Filter: '',
  Metrics: '',
  NextToken: '',
  MaxResults: '',
  SortBy: ''
});

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=AWSInsightsIndexService.GetSavingsPlansCoverage');
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=AWSInsightsIndexService.GetSavingsPlansCoverage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TimePeriod: '',
    GroupBy: '',
    Granularity: '',
    Filter: '',
    Metrics: '',
    NextToken: '',
    MaxResults: '',
    SortBy: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansCoverage';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TimePeriod":"","GroupBy":"","Granularity":"","Filter":"","Metrics":"","NextToken":"","MaxResults":"","SortBy":""}'
};

try {
  const response = await 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=AWSInsightsIndexService.GetSavingsPlansCoverage',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TimePeriod": "",\n  "GroupBy": "",\n  "Granularity": "",\n  "Filter": "",\n  "Metrics": "",\n  "NextToken": "",\n  "MaxResults": "",\n  "SortBy": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"SortBy\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansCoverage")
  .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({
  TimePeriod: '',
  GroupBy: '',
  Granularity: '',
  Filter: '',
  Metrics: '',
  NextToken: '',
  MaxResults: '',
  SortBy: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansCoverage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    TimePeriod: '',
    GroupBy: '',
    Granularity: '',
    Filter: '',
    Metrics: '',
    NextToken: '',
    MaxResults: '',
    SortBy: ''
  },
  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=AWSInsightsIndexService.GetSavingsPlansCoverage');

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

req.type('json');
req.send({
  TimePeriod: '',
  GroupBy: '',
  Granularity: '',
  Filter: '',
  Metrics: '',
  NextToken: '',
  MaxResults: '',
  SortBy: ''
});

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=AWSInsightsIndexService.GetSavingsPlansCoverage',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TimePeriod: '',
    GroupBy: '',
    Granularity: '',
    Filter: '',
    Metrics: '',
    NextToken: '',
    MaxResults: '',
    SortBy: ''
  }
};

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=AWSInsightsIndexService.GetSavingsPlansCoverage';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TimePeriod":"","GroupBy":"","Granularity":"","Filter":"","Metrics":"","NextToken":"","MaxResults":"","SortBy":""}'
};

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 = @{ @"TimePeriod": @"",
                              @"GroupBy": @"",
                              @"Granularity": @"",
                              @"Filter": @"",
                              @"Metrics": @"",
                              @"NextToken": @"",
                              @"MaxResults": @"",
                              @"SortBy": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansCoverage"]
                                                       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=AWSInsightsIndexService.GetSavingsPlansCoverage" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"SortBy\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansCoverage",
  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([
    'TimePeriod' => '',
    'GroupBy' => '',
    'Granularity' => '',
    'Filter' => '',
    'Metrics' => '',
    'NextToken' => '',
    'MaxResults' => '',
    'SortBy' => ''
  ]),
  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=AWSInsightsIndexService.GetSavingsPlansCoverage', [
  'body' => '{
  "TimePeriod": "",
  "GroupBy": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "NextToken": "",
  "MaxResults": "",
  "SortBy": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TimePeriod' => '',
  'GroupBy' => '',
  'Granularity' => '',
  'Filter' => '',
  'Metrics' => '',
  'NextToken' => '',
  'MaxResults' => '',
  'SortBy' => ''
]));

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

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

append(json_encode([
  'TimePeriod' => '',
  'GroupBy' => '',
  'Granularity' => '',
  'Filter' => '',
  'Metrics' => '',
  'NextToken' => '',
  'MaxResults' => '',
  'SortBy' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansCoverage');
$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=AWSInsightsIndexService.GetSavingsPlansCoverage' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TimePeriod": "",
  "GroupBy": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "NextToken": "",
  "MaxResults": "",
  "SortBy": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansCoverage' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TimePeriod": "",
  "GroupBy": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "NextToken": "",
  "MaxResults": "",
  "SortBy": ""
}'

import http.client

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

payload = "{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"SortBy\": \"\"\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=AWSInsightsIndexService.GetSavingsPlansCoverage"

payload = {
    "TimePeriod": "",
    "GroupBy": "",
    "Granularity": "",
    "Filter": "",
    "Metrics": "",
    "NextToken": "",
    "MaxResults": "",
    "SortBy": ""
}
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=AWSInsightsIndexService.GetSavingsPlansCoverage"

payload <- "{\n  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"SortBy\": \"\"\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=AWSInsightsIndexService.GetSavingsPlansCoverage")

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  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"SortBy\": \"\"\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  \"TimePeriod\": \"\",\n  \"GroupBy\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"Metrics\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"SortBy\": \"\"\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=AWSInsightsIndexService.GetSavingsPlansCoverage";

    let payload = json!({
        "TimePeriod": "",
        "GroupBy": "",
        "Granularity": "",
        "Filter": "",
        "Metrics": "",
        "NextToken": "",
        "MaxResults": "",
        "SortBy": ""
    });

    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=AWSInsightsIndexService.GetSavingsPlansCoverage' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "TimePeriod": "",
  "GroupBy": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "NextToken": "",
  "MaxResults": "",
  "SortBy": ""
}'

echo '{
  "TimePeriod": "",
  "GroupBy": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "NextToken": "",
  "MaxResults": "",
  "SortBy": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansCoverage' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TimePeriod": "",\n  "GroupBy": "",\n  "Granularity": "",\n  "Filter": "",\n  "Metrics": "",\n  "NextToken": "",\n  "MaxResults": "",\n  "SortBy": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansCoverage'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TimePeriod": "",
  "GroupBy": "",
  "Granularity": "",
  "Filter": "",
  "Metrics": "",
  "NextToken": "",
  "MaxResults": "",
  "SortBy": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation

HEADERS

X-Amz-Target

BODY json

{
  "SavingsPlansType": "",
  "TermInYears": "",
  "PaymentOption": "",
  "AccountScope": "",
  "NextPageToken": "",
  "PageSize": "",
  "LookbackPeriodInDays": "",
  "Filter": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"SavingsPlansType\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"AccountScope\": \"\",\n  \"NextPageToken\": \"\",\n  \"PageSize\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"Filter\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation" {:headers {:x-amz-target ""}
                                                                                                                        :content-type :json
                                                                                                                        :form-params {:SavingsPlansType ""
                                                                                                                                      :TermInYears ""
                                                                                                                                      :PaymentOption ""
                                                                                                                                      :AccountScope ""
                                                                                                                                      :NextPageToken ""
                                                                                                                                      :PageSize ""
                                                                                                                                      :LookbackPeriodInDays ""
                                                                                                                                      :Filter ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"SavingsPlansType\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"AccountScope\": \"\",\n  \"NextPageToken\": \"\",\n  \"PageSize\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"Filter\": \"\"\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=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"SavingsPlansType\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"AccountScope\": \"\",\n  \"NextPageToken\": \"\",\n  \"PageSize\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"Filter\": \"\"\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=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"SavingsPlansType\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"AccountScope\": \"\",\n  \"NextPageToken\": \"\",\n  \"PageSize\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"Filter\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation"

	payload := strings.NewReader("{\n  \"SavingsPlansType\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"AccountScope\": \"\",\n  \"NextPageToken\": \"\",\n  \"PageSize\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"Filter\": \"\"\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: 181

{
  "SavingsPlansType": "",
  "TermInYears": "",
  "PaymentOption": "",
  "AccountScope": "",
  "NextPageToken": "",
  "PageSize": "",
  "LookbackPeriodInDays": "",
  "Filter": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"SavingsPlansType\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"AccountScope\": \"\",\n  \"NextPageToken\": \"\",\n  \"PageSize\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"Filter\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"SavingsPlansType\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"AccountScope\": \"\",\n  \"NextPageToken\": \"\",\n  \"PageSize\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"Filter\": \"\"\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  \"SavingsPlansType\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"AccountScope\": \"\",\n  \"NextPageToken\": \"\",\n  \"PageSize\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"Filter\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation")
  .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=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"SavingsPlansType\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"AccountScope\": \"\",\n  \"NextPageToken\": \"\",\n  \"PageSize\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"Filter\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  SavingsPlansType: '',
  TermInYears: '',
  PaymentOption: '',
  AccountScope: '',
  NextPageToken: '',
  PageSize: '',
  LookbackPeriodInDays: '',
  Filter: ''
});

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=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation');
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=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    SavingsPlansType: '',
    TermInYears: '',
    PaymentOption: '',
    AccountScope: '',
    NextPageToken: '',
    PageSize: '',
    LookbackPeriodInDays: '',
    Filter: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SavingsPlansType":"","TermInYears":"","PaymentOption":"","AccountScope":"","NextPageToken":"","PageSize":"","LookbackPeriodInDays":"","Filter":""}'
};

try {
  const response = await 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=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SavingsPlansType": "",\n  "TermInYears": "",\n  "PaymentOption": "",\n  "AccountScope": "",\n  "NextPageToken": "",\n  "PageSize": "",\n  "LookbackPeriodInDays": "",\n  "Filter": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"SavingsPlansType\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"AccountScope\": \"\",\n  \"NextPageToken\": \"\",\n  \"PageSize\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"Filter\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation")
  .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({
  SavingsPlansType: '',
  TermInYears: '',
  PaymentOption: '',
  AccountScope: '',
  NextPageToken: '',
  PageSize: '',
  LookbackPeriodInDays: '',
  Filter: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    SavingsPlansType: '',
    TermInYears: '',
    PaymentOption: '',
    AccountScope: '',
    NextPageToken: '',
    PageSize: '',
    LookbackPeriodInDays: '',
    Filter: ''
  },
  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=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation');

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

req.type('json');
req.send({
  SavingsPlansType: '',
  TermInYears: '',
  PaymentOption: '',
  AccountScope: '',
  NextPageToken: '',
  PageSize: '',
  LookbackPeriodInDays: '',
  Filter: ''
});

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=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    SavingsPlansType: '',
    TermInYears: '',
    PaymentOption: '',
    AccountScope: '',
    NextPageToken: '',
    PageSize: '',
    LookbackPeriodInDays: '',
    Filter: ''
  }
};

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=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SavingsPlansType":"","TermInYears":"","PaymentOption":"","AccountScope":"","NextPageToken":"","PageSize":"","LookbackPeriodInDays":"","Filter":""}'
};

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 = @{ @"SavingsPlansType": @"",
                              @"TermInYears": @"",
                              @"PaymentOption": @"",
                              @"AccountScope": @"",
                              @"NextPageToken": @"",
                              @"PageSize": @"",
                              @"LookbackPeriodInDays": @"",
                              @"Filter": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation"]
                                                       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=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"SavingsPlansType\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"AccountScope\": \"\",\n  \"NextPageToken\": \"\",\n  \"PageSize\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"Filter\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation",
  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([
    'SavingsPlansType' => '',
    'TermInYears' => '',
    'PaymentOption' => '',
    'AccountScope' => '',
    'NextPageToken' => '',
    'PageSize' => '',
    'LookbackPeriodInDays' => '',
    'Filter' => ''
  ]),
  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=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation', [
  'body' => '{
  "SavingsPlansType": "",
  "TermInYears": "",
  "PaymentOption": "",
  "AccountScope": "",
  "NextPageToken": "",
  "PageSize": "",
  "LookbackPeriodInDays": "",
  "Filter": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'SavingsPlansType' => '',
  'TermInYears' => '',
  'PaymentOption' => '',
  'AccountScope' => '',
  'NextPageToken' => '',
  'PageSize' => '',
  'LookbackPeriodInDays' => '',
  'Filter' => ''
]));

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

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

append(json_encode([
  'SavingsPlansType' => '',
  'TermInYears' => '',
  'PaymentOption' => '',
  'AccountScope' => '',
  'NextPageToken' => '',
  'PageSize' => '',
  'LookbackPeriodInDays' => '',
  'Filter' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation');
$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=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SavingsPlansType": "",
  "TermInYears": "",
  "PaymentOption": "",
  "AccountScope": "",
  "NextPageToken": "",
  "PageSize": "",
  "LookbackPeriodInDays": "",
  "Filter": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SavingsPlansType": "",
  "TermInYears": "",
  "PaymentOption": "",
  "AccountScope": "",
  "NextPageToken": "",
  "PageSize": "",
  "LookbackPeriodInDays": "",
  "Filter": ""
}'

import http.client

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

payload = "{\n  \"SavingsPlansType\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"AccountScope\": \"\",\n  \"NextPageToken\": \"\",\n  \"PageSize\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"Filter\": \"\"\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=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation"

payload = {
    "SavingsPlansType": "",
    "TermInYears": "",
    "PaymentOption": "",
    "AccountScope": "",
    "NextPageToken": "",
    "PageSize": "",
    "LookbackPeriodInDays": "",
    "Filter": ""
}
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=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation"

payload <- "{\n  \"SavingsPlansType\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"AccountScope\": \"\",\n  \"NextPageToken\": \"\",\n  \"PageSize\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"Filter\": \"\"\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=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation")

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  \"SavingsPlansType\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"AccountScope\": \"\",\n  \"NextPageToken\": \"\",\n  \"PageSize\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"Filter\": \"\"\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  \"SavingsPlansType\": \"\",\n  \"TermInYears\": \"\",\n  \"PaymentOption\": \"\",\n  \"AccountScope\": \"\",\n  \"NextPageToken\": \"\",\n  \"PageSize\": \"\",\n  \"LookbackPeriodInDays\": \"\",\n  \"Filter\": \"\"\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=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation";

    let payload = json!({
        "SavingsPlansType": "",
        "TermInYears": "",
        "PaymentOption": "",
        "AccountScope": "",
        "NextPageToken": "",
        "PageSize": "",
        "LookbackPeriodInDays": "",
        "Filter": ""
    });

    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=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "SavingsPlansType": "",
  "TermInYears": "",
  "PaymentOption": "",
  "AccountScope": "",
  "NextPageToken": "",
  "PageSize": "",
  "LookbackPeriodInDays": "",
  "Filter": ""
}'

echo '{
  "SavingsPlansType": "",
  "TermInYears": "",
  "PaymentOption": "",
  "AccountScope": "",
  "NextPageToken": "",
  "PageSize": "",
  "LookbackPeriodInDays": "",
  "Filter": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "SavingsPlansType": "",\n  "TermInYears": "",\n  "PaymentOption": "",\n  "AccountScope": "",\n  "NextPageToken": "",\n  "PageSize": "",\n  "LookbackPeriodInDays": "",\n  "Filter": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansPurchaseRecommendation'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "SavingsPlansType": "",
  "TermInYears": "",
  "PaymentOption": "",
  "AccountScope": "",
  "NextPageToken": "",
  "PageSize": "",
  "LookbackPeriodInDays": "",
  "Filter": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilization

HEADERS

X-Amz-Target

BODY json

{
  "TimePeriod": "",
  "Granularity": "",
  "Filter": "",
  "SortBy": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"SortBy\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilization" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:TimePeriod ""
                                                                                                                           :Granularity ""
                                                                                                                           :Filter ""
                                                                                                                           :SortBy ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilization"

	payload := strings.NewReader("{\n  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"SortBy\": \"\"\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: 75

{
  "TimePeriod": "",
  "Granularity": "",
  "Filter": "",
  "SortBy": ""
}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilization"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"SortBy\": \"\"\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  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"SortBy\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilization")
  .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=AWSInsightsIndexService.GetSavingsPlansUtilization")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"SortBy\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TimePeriod: '',
  Granularity: '',
  Filter: '',
  SortBy: ''
});

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=AWSInsightsIndexService.GetSavingsPlansUtilization');
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=AWSInsightsIndexService.GetSavingsPlansUtilization',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TimePeriod: '', Granularity: '', Filter: '', SortBy: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilization';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TimePeriod":"","Granularity":"","Filter":"","SortBy":""}'
};

try {
  const response = await 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=AWSInsightsIndexService.GetSavingsPlansUtilization',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TimePeriod": "",\n  "Granularity": "",\n  "Filter": "",\n  "SortBy": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"SortBy\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilization")
  .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({TimePeriod: '', Granularity: '', Filter: '', SortBy: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilization',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {TimePeriod: '', Granularity: '', Filter: '', SortBy: ''},
  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=AWSInsightsIndexService.GetSavingsPlansUtilization');

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

req.type('json');
req.send({
  TimePeriod: '',
  Granularity: '',
  Filter: '',
  SortBy: ''
});

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=AWSInsightsIndexService.GetSavingsPlansUtilization',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {TimePeriod: '', Granularity: '', Filter: '', SortBy: ''}
};

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=AWSInsightsIndexService.GetSavingsPlansUtilization';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TimePeriod":"","Granularity":"","Filter":"","SortBy":""}'
};

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 = @{ @"TimePeriod": @"",
                              @"Granularity": @"",
                              @"Filter": @"",
                              @"SortBy": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilization",
  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([
    'TimePeriod' => '',
    'Granularity' => '',
    'Filter' => '',
    'SortBy' => ''
  ]),
  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=AWSInsightsIndexService.GetSavingsPlansUtilization', [
  'body' => '{
  "TimePeriod": "",
  "Granularity": "",
  "Filter": "",
  "SortBy": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TimePeriod' => '',
  'Granularity' => '',
  'Filter' => '',
  'SortBy' => ''
]));

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

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

append(json_encode([
  'TimePeriod' => '',
  'Granularity' => '',
  'Filter' => '',
  'SortBy' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilization');
$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=AWSInsightsIndexService.GetSavingsPlansUtilization' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TimePeriod": "",
  "Granularity": "",
  "Filter": "",
  "SortBy": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilization' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TimePeriod": "",
  "Granularity": "",
  "Filter": "",
  "SortBy": ""
}'

import http.client

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

payload = "{\n  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"SortBy\": \"\"\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=AWSInsightsIndexService.GetSavingsPlansUtilization"

payload = {
    "TimePeriod": "",
    "Granularity": "",
    "Filter": "",
    "SortBy": ""
}
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=AWSInsightsIndexService.GetSavingsPlansUtilization"

payload <- "{\n  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"SortBy\": \"\"\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=AWSInsightsIndexService.GetSavingsPlansUtilization")

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  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"SortBy\": \"\"\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  \"TimePeriod\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"SortBy\": \"\"\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=AWSInsightsIndexService.GetSavingsPlansUtilization";

    let payload = json!({
        "TimePeriod": "",
        "Granularity": "",
        "Filter": "",
        "SortBy": ""
    });

    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=AWSInsightsIndexService.GetSavingsPlansUtilization' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "TimePeriod": "",
  "Granularity": "",
  "Filter": "",
  "SortBy": ""
}'

echo '{
  "TimePeriod": "",
  "Granularity": "",
  "Filter": "",
  "SortBy": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilization' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TimePeriod": "",\n  "Granularity": "",\n  "Filter": "",\n  "SortBy": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilization'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails

HEADERS

X-Amz-Target

BODY json

{
  "TimePeriod": "",
  "Filter": "",
  "DataType": "",
  "NextToken": "",
  "MaxResults": "",
  "SortBy": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"TimePeriod\": \"\",\n  \"Filter\": \"\",\n  \"DataType\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"SortBy\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails" {:headers {:x-amz-target ""}
                                                                                                                    :content-type :json
                                                                                                                    :form-params {:TimePeriod ""
                                                                                                                                  :Filter ""
                                                                                                                                  :DataType ""
                                                                                                                                  :NextToken ""
                                                                                                                                  :MaxResults ""
                                                                                                                                  :SortBy ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails"

	payload := strings.NewReader("{\n  \"TimePeriod\": \"\",\n  \"Filter\": \"\",\n  \"DataType\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"SortBy\": \"\"\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: 111

{
  "TimePeriod": "",
  "Filter": "",
  "DataType": "",
  "NextToken": "",
  "MaxResults": "",
  "SortBy": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TimePeriod\": \"\",\n  \"Filter\": \"\",\n  \"DataType\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"SortBy\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TimePeriod\": \"\",\n  \"Filter\": \"\",\n  \"DataType\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"SortBy\": \"\"\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  \"TimePeriod\": \"\",\n  \"Filter\": \"\",\n  \"DataType\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"SortBy\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails")
  .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=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TimePeriod\": \"\",\n  \"Filter\": \"\",\n  \"DataType\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"SortBy\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TimePeriod: '',
  Filter: '',
  DataType: '',
  NextToken: '',
  MaxResults: '',
  SortBy: ''
});

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=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails');
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=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TimePeriod: '',
    Filter: '',
    DataType: '',
    NextToken: '',
    MaxResults: '',
    SortBy: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TimePeriod":"","Filter":"","DataType":"","NextToken":"","MaxResults":"","SortBy":""}'
};

try {
  const response = await 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=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TimePeriod": "",\n  "Filter": "",\n  "DataType": "",\n  "NextToken": "",\n  "MaxResults": "",\n  "SortBy": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TimePeriod\": \"\",\n  \"Filter\": \"\",\n  \"DataType\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"SortBy\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails")
  .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({
  TimePeriod: '',
  Filter: '',
  DataType: '',
  NextToken: '',
  MaxResults: '',
  SortBy: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    TimePeriod: '',
    Filter: '',
    DataType: '',
    NextToken: '',
    MaxResults: '',
    SortBy: ''
  },
  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=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails');

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

req.type('json');
req.send({
  TimePeriod: '',
  Filter: '',
  DataType: '',
  NextToken: '',
  MaxResults: '',
  SortBy: ''
});

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=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TimePeriod: '',
    Filter: '',
    DataType: '',
    NextToken: '',
    MaxResults: '',
    SortBy: ''
  }
};

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=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TimePeriod":"","Filter":"","DataType":"","NextToken":"","MaxResults":"","SortBy":""}'
};

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 = @{ @"TimePeriod": @"",
                              @"Filter": @"",
                              @"DataType": @"",
                              @"NextToken": @"",
                              @"MaxResults": @"",
                              @"SortBy": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails",
  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([
    'TimePeriod' => '',
    'Filter' => '',
    'DataType' => '',
    'NextToken' => '',
    'MaxResults' => '',
    'SortBy' => ''
  ]),
  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=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails', [
  'body' => '{
  "TimePeriod": "",
  "Filter": "",
  "DataType": "",
  "NextToken": "",
  "MaxResults": "",
  "SortBy": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TimePeriod' => '',
  'Filter' => '',
  'DataType' => '',
  'NextToken' => '',
  'MaxResults' => '',
  'SortBy' => ''
]));

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

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

append(json_encode([
  'TimePeriod' => '',
  'Filter' => '',
  'DataType' => '',
  'NextToken' => '',
  'MaxResults' => '',
  'SortBy' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails');
$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=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TimePeriod": "",
  "Filter": "",
  "DataType": "",
  "NextToken": "",
  "MaxResults": "",
  "SortBy": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TimePeriod": "",
  "Filter": "",
  "DataType": "",
  "NextToken": "",
  "MaxResults": "",
  "SortBy": ""
}'

import http.client

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

payload = "{\n  \"TimePeriod\": \"\",\n  \"Filter\": \"\",\n  \"DataType\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"SortBy\": \"\"\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=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails"

payload = {
    "TimePeriod": "",
    "Filter": "",
    "DataType": "",
    "NextToken": "",
    "MaxResults": "",
    "SortBy": ""
}
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=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails"

payload <- "{\n  \"TimePeriod\": \"\",\n  \"Filter\": \"\",\n  \"DataType\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"SortBy\": \"\"\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=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails")

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  \"TimePeriod\": \"\",\n  \"Filter\": \"\",\n  \"DataType\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"SortBy\": \"\"\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  \"TimePeriod\": \"\",\n  \"Filter\": \"\",\n  \"DataType\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"SortBy\": \"\"\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=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails";

    let payload = json!({
        "TimePeriod": "",
        "Filter": "",
        "DataType": "",
        "NextToken": "",
        "MaxResults": "",
        "SortBy": ""
    });

    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=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "TimePeriod": "",
  "Filter": "",
  "DataType": "",
  "NextToken": "",
  "MaxResults": "",
  "SortBy": ""
}'

echo '{
  "TimePeriod": "",
  "Filter": "",
  "DataType": "",
  "NextToken": "",
  "MaxResults": "",
  "SortBy": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TimePeriod": "",\n  "Filter": "",\n  "DataType": "",\n  "NextToken": "",\n  "MaxResults": "",\n  "SortBy": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetSavingsPlansUtilizationDetails'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TimePeriod": "",
  "Filter": "",
  "DataType": "",
  "NextToken": "",
  "MaxResults": "",
  "SortBy": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetTags

HEADERS

X-Amz-Target

BODY json

{
  "SearchString": "",
  "TimePeriod": "",
  "TagKey": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "SortBy": "",
  "MaxResults": "",
  "NextPageToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"TagKey\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetTags" {:headers {:x-amz-target ""}
                                                                                          :content-type :json
                                                                                          :form-params {:SearchString ""
                                                                                                        :TimePeriod ""
                                                                                                        :TagKey ""
                                                                                                        :Filter {:Or ""
                                                                                                                 :And ""
                                                                                                                 :Not ""
                                                                                                                 :Dimensions ""
                                                                                                                 :Tags ""
                                                                                                                 :CostCategories ""}
                                                                                                        :SortBy ""
                                                                                                        :MaxResults ""
                                                                                                        :NextPageToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetTags"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"TagKey\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetTags"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"TagKey\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetTags");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"TagKey\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetTags"

	payload := strings.NewReader("{\n  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"TagKey\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\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: 245

{
  "SearchString": "",
  "TimePeriod": "",
  "TagKey": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "SortBy": "",
  "MaxResults": "",
  "NextPageToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetTags")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"TagKey\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetTags"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"TagKey\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\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  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"TagKey\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetTags")
  .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=AWSInsightsIndexService.GetTags")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"TagKey\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  SearchString: '',
  TimePeriod: '',
  TagKey: '',
  Filter: {
    Or: '',
    And: '',
    Not: '',
    Dimensions: '',
    Tags: '',
    CostCategories: ''
  },
  SortBy: '',
  MaxResults: '',
  NextPageToken: ''
});

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=AWSInsightsIndexService.GetTags');
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=AWSInsightsIndexService.GetTags',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    SearchString: '',
    TimePeriod: '',
    TagKey: '',
    Filter: {Or: '', And: '', Not: '', Dimensions: '', Tags: '', CostCategories: ''},
    SortBy: '',
    MaxResults: '',
    NextPageToken: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetTags';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SearchString":"","TimePeriod":"","TagKey":"","Filter":{"Or":"","And":"","Not":"","Dimensions":"","Tags":"","CostCategories":""},"SortBy":"","MaxResults":"","NextPageToken":""}'
};

try {
  const response = await 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=AWSInsightsIndexService.GetTags',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SearchString": "",\n  "TimePeriod": "",\n  "TagKey": "",\n  "Filter": {\n    "Or": "",\n    "And": "",\n    "Not": "",\n    "Dimensions": "",\n    "Tags": "",\n    "CostCategories": ""\n  },\n  "SortBy": "",\n  "MaxResults": "",\n  "NextPageToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"TagKey\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetTags")
  .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({
  SearchString: '',
  TimePeriod: '',
  TagKey: '',
  Filter: {Or: '', And: '', Not: '', Dimensions: '', Tags: '', CostCategories: ''},
  SortBy: '',
  MaxResults: '',
  NextPageToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetTags',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    SearchString: '',
    TimePeriod: '',
    TagKey: '',
    Filter: {Or: '', And: '', Not: '', Dimensions: '', Tags: '', CostCategories: ''},
    SortBy: '',
    MaxResults: '',
    NextPageToken: ''
  },
  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=AWSInsightsIndexService.GetTags');

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

req.type('json');
req.send({
  SearchString: '',
  TimePeriod: '',
  TagKey: '',
  Filter: {
    Or: '',
    And: '',
    Not: '',
    Dimensions: '',
    Tags: '',
    CostCategories: ''
  },
  SortBy: '',
  MaxResults: '',
  NextPageToken: ''
});

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=AWSInsightsIndexService.GetTags',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    SearchString: '',
    TimePeriod: '',
    TagKey: '',
    Filter: {Or: '', And: '', Not: '', Dimensions: '', Tags: '', CostCategories: ''},
    SortBy: '',
    MaxResults: '',
    NextPageToken: ''
  }
};

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=AWSInsightsIndexService.GetTags';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SearchString":"","TimePeriod":"","TagKey":"","Filter":{"Or":"","And":"","Not":"","Dimensions":"","Tags":"","CostCategories":""},"SortBy":"","MaxResults":"","NextPageToken":""}'
};

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 = @{ @"SearchString": @"",
                              @"TimePeriod": @"",
                              @"TagKey": @"",
                              @"Filter": @{ @"Or": @"", @"And": @"", @"Not": @"", @"Dimensions": @"", @"Tags": @"", @"CostCategories": @"" },
                              @"SortBy": @"",
                              @"MaxResults": @"",
                              @"NextPageToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetTags"]
                                                       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=AWSInsightsIndexService.GetTags" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"TagKey\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetTags",
  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([
    'SearchString' => '',
    'TimePeriod' => '',
    'TagKey' => '',
    'Filter' => [
        'Or' => '',
        'And' => '',
        'Not' => '',
        'Dimensions' => '',
        'Tags' => '',
        'CostCategories' => ''
    ],
    'SortBy' => '',
    'MaxResults' => '',
    'NextPageToken' => ''
  ]),
  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=AWSInsightsIndexService.GetTags', [
  'body' => '{
  "SearchString": "",
  "TimePeriod": "",
  "TagKey": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "SortBy": "",
  "MaxResults": "",
  "NextPageToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'SearchString' => '',
  'TimePeriod' => '',
  'TagKey' => '',
  'Filter' => [
    'Or' => '',
    'And' => '',
    'Not' => '',
    'Dimensions' => '',
    'Tags' => '',
    'CostCategories' => ''
  ],
  'SortBy' => '',
  'MaxResults' => '',
  'NextPageToken' => ''
]));

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

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

append(json_encode([
  'SearchString' => '',
  'TimePeriod' => '',
  'TagKey' => '',
  'Filter' => [
    'Or' => '',
    'And' => '',
    'Not' => '',
    'Dimensions' => '',
    'Tags' => '',
    'CostCategories' => ''
  ],
  'SortBy' => '',
  'MaxResults' => '',
  'NextPageToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetTags');
$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=AWSInsightsIndexService.GetTags' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SearchString": "",
  "TimePeriod": "",
  "TagKey": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "SortBy": "",
  "MaxResults": "",
  "NextPageToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetTags' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SearchString": "",
  "TimePeriod": "",
  "TagKey": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "SortBy": "",
  "MaxResults": "",
  "NextPageToken": ""
}'

import http.client

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

payload = "{\n  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"TagKey\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetTags"

payload = {
    "SearchString": "",
    "TimePeriod": "",
    "TagKey": "",
    "Filter": {
        "Or": "",
        "And": "",
        "Not": "",
        "Dimensions": "",
        "Tags": "",
        "CostCategories": ""
    },
    "SortBy": "",
    "MaxResults": "",
    "NextPageToken": ""
}
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=AWSInsightsIndexService.GetTags"

payload <- "{\n  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"TagKey\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetTags")

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  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"TagKey\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\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  \"SearchString\": \"\",\n  \"TimePeriod\": \"\",\n  \"TagKey\": \"\",\n  \"Filter\": {\n    \"Or\": \"\",\n    \"And\": \"\",\n    \"Not\": \"\",\n    \"Dimensions\": \"\",\n    \"Tags\": \"\",\n    \"CostCategories\": \"\"\n  },\n  \"SortBy\": \"\",\n  \"MaxResults\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.GetTags";

    let payload = json!({
        "SearchString": "",
        "TimePeriod": "",
        "TagKey": "",
        "Filter": json!({
            "Or": "",
            "And": "",
            "Not": "",
            "Dimensions": "",
            "Tags": "",
            "CostCategories": ""
        }),
        "SortBy": "",
        "MaxResults": "",
        "NextPageToken": ""
    });

    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=AWSInsightsIndexService.GetTags' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "SearchString": "",
  "TimePeriod": "",
  "TagKey": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "SortBy": "",
  "MaxResults": "",
  "NextPageToken": ""
}'

echo '{
  "SearchString": "",
  "TimePeriod": "",
  "TagKey": "",
  "Filter": {
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  },
  "SortBy": "",
  "MaxResults": "",
  "NextPageToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetTags' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "SearchString": "",\n  "TimePeriod": "",\n  "TagKey": "",\n  "Filter": {\n    "Or": "",\n    "And": "",\n    "Not": "",\n    "Dimensions": "",\n    "Tags": "",\n    "CostCategories": ""\n  },\n  "SortBy": "",\n  "MaxResults": "",\n  "NextPageToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetTags'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "SearchString": "",
  "TimePeriod": "",
  "TagKey": "",
  "Filter": [
    "Or": "",
    "And": "",
    "Not": "",
    "Dimensions": "",
    "Tags": "",
    "CostCategories": ""
  ],
  "SortBy": "",
  "MaxResults": "",
  "NextPageToken": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetUsageForecast

HEADERS

X-Amz-Target

BODY json

{
  "TimePeriod": "",
  "Metric": "",
  "Granularity": "",
  "Filter": "",
  "PredictionIntervalLevel": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"TimePeriod\": \"\",\n  \"Metric\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"PredictionIntervalLevel\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetUsageForecast" {:headers {:x-amz-target ""}
                                                                                                   :content-type :json
                                                                                                   :form-params {:TimePeriod ""
                                                                                                                 :Metric ""
                                                                                                                 :Granularity ""
                                                                                                                 :Filter ""
                                                                                                                 :PredictionIntervalLevel ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetUsageForecast"

	payload := strings.NewReader("{\n  \"TimePeriod\": \"\",\n  \"Metric\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"PredictionIntervalLevel\": \"\"\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: 108

{
  "TimePeriod": "",
  "Metric": "",
  "Granularity": "",
  "Filter": "",
  "PredictionIntervalLevel": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetUsageForecast")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"TimePeriod\": \"\",\n  \"Metric\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"PredictionIntervalLevel\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetUsageForecast"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"TimePeriod\": \"\",\n  \"Metric\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"PredictionIntervalLevel\": \"\"\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  \"TimePeriod\": \"\",\n  \"Metric\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"PredictionIntervalLevel\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetUsageForecast")
  .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=AWSInsightsIndexService.GetUsageForecast")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"TimePeriod\": \"\",\n  \"Metric\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"PredictionIntervalLevel\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  TimePeriod: '',
  Metric: '',
  Granularity: '',
  Filter: '',
  PredictionIntervalLevel: ''
});

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=AWSInsightsIndexService.GetUsageForecast');
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=AWSInsightsIndexService.GetUsageForecast',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TimePeriod: '',
    Metric: '',
    Granularity: '',
    Filter: '',
    PredictionIntervalLevel: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetUsageForecast';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TimePeriod":"","Metric":"","Granularity":"","Filter":"","PredictionIntervalLevel":""}'
};

try {
  const response = await 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=AWSInsightsIndexService.GetUsageForecast',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "TimePeriod": "",\n  "Metric": "",\n  "Granularity": "",\n  "Filter": "",\n  "PredictionIntervalLevel": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"TimePeriod\": \"\",\n  \"Metric\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"PredictionIntervalLevel\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetUsageForecast")
  .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({
  TimePeriod: '',
  Metric: '',
  Granularity: '',
  Filter: '',
  PredictionIntervalLevel: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetUsageForecast',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    TimePeriod: '',
    Metric: '',
    Granularity: '',
    Filter: '',
    PredictionIntervalLevel: ''
  },
  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=AWSInsightsIndexService.GetUsageForecast');

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

req.type('json');
req.send({
  TimePeriod: '',
  Metric: '',
  Granularity: '',
  Filter: '',
  PredictionIntervalLevel: ''
});

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=AWSInsightsIndexService.GetUsageForecast',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    TimePeriod: '',
    Metric: '',
    Granularity: '',
    Filter: '',
    PredictionIntervalLevel: ''
  }
};

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=AWSInsightsIndexService.GetUsageForecast';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"TimePeriod":"","Metric":"","Granularity":"","Filter":"","PredictionIntervalLevel":""}'
};

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 = @{ @"TimePeriod": @"",
                              @"Metric": @"",
                              @"Granularity": @"",
                              @"Filter": @"",
                              @"PredictionIntervalLevel": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetUsageForecast",
  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([
    'TimePeriod' => '',
    'Metric' => '',
    'Granularity' => '',
    'Filter' => '',
    'PredictionIntervalLevel' => ''
  ]),
  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=AWSInsightsIndexService.GetUsageForecast', [
  'body' => '{
  "TimePeriod": "",
  "Metric": "",
  "Granularity": "",
  "Filter": "",
  "PredictionIntervalLevel": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'TimePeriod' => '',
  'Metric' => '',
  'Granularity' => '',
  'Filter' => '',
  'PredictionIntervalLevel' => ''
]));

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

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

append(json_encode([
  'TimePeriod' => '',
  'Metric' => '',
  'Granularity' => '',
  'Filter' => '',
  'PredictionIntervalLevel' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetUsageForecast');
$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=AWSInsightsIndexService.GetUsageForecast' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TimePeriod": "",
  "Metric": "",
  "Granularity": "",
  "Filter": "",
  "PredictionIntervalLevel": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetUsageForecast' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "TimePeriod": "",
  "Metric": "",
  "Granularity": "",
  "Filter": "",
  "PredictionIntervalLevel": ""
}'

import http.client

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

payload = "{\n  \"TimePeriod\": \"\",\n  \"Metric\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"PredictionIntervalLevel\": \"\"\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=AWSInsightsIndexService.GetUsageForecast"

payload = {
    "TimePeriod": "",
    "Metric": "",
    "Granularity": "",
    "Filter": "",
    "PredictionIntervalLevel": ""
}
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=AWSInsightsIndexService.GetUsageForecast"

payload <- "{\n  \"TimePeriod\": \"\",\n  \"Metric\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"PredictionIntervalLevel\": \"\"\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=AWSInsightsIndexService.GetUsageForecast")

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  \"TimePeriod\": \"\",\n  \"Metric\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"PredictionIntervalLevel\": \"\"\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  \"TimePeriod\": \"\",\n  \"Metric\": \"\",\n  \"Granularity\": \"\",\n  \"Filter\": \"\",\n  \"PredictionIntervalLevel\": \"\"\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=AWSInsightsIndexService.GetUsageForecast";

    let payload = json!({
        "TimePeriod": "",
        "Metric": "",
        "Granularity": "",
        "Filter": "",
        "PredictionIntervalLevel": ""
    });

    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=AWSInsightsIndexService.GetUsageForecast' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "TimePeriod": "",
  "Metric": "",
  "Granularity": "",
  "Filter": "",
  "PredictionIntervalLevel": ""
}'

echo '{
  "TimePeriod": "",
  "Metric": "",
  "Granularity": "",
  "Filter": "",
  "PredictionIntervalLevel": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetUsageForecast' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "TimePeriod": "",\n  "Metric": "",\n  "Granularity": "",\n  "Filter": "",\n  "PredictionIntervalLevel": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.GetUsageForecast'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "TimePeriod": "",
  "Metric": "",
  "Granularity": "",
  "Filter": "",
  "PredictionIntervalLevel": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListCostAllocationTags

HEADERS

X-Amz-Target

BODY json

{
  "Status": "",
  "TagKeys": "",
  "Type": "",
  "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=AWSInsightsIndexService.ListCostAllocationTags");

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  \"Status\": \"\",\n  \"TagKeys\": \"\",\n  \"Type\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListCostAllocationTags" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:Status ""
                                                                                                                       :TagKeys ""
                                                                                                                       :Type ""
                                                                                                                       :NextToken ""
                                                                                                                       :MaxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListCostAllocationTags"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Status\": \"\",\n  \"TagKeys\": \"\",\n  \"Type\": \"\",\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=AWSInsightsIndexService.ListCostAllocationTags"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Status\": \"\",\n  \"TagKeys\": \"\",\n  \"Type\": \"\",\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=AWSInsightsIndexService.ListCostAllocationTags");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"Status\": \"\",\n  \"TagKeys\": \"\",\n  \"Type\": \"\",\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=AWSInsightsIndexService.ListCostAllocationTags"

	payload := strings.NewReader("{\n  \"Status\": \"\",\n  \"TagKeys\": \"\",\n  \"Type\": \"\",\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: 88

{
  "Status": "",
  "TagKeys": "",
  "Type": "",
  "NextToken": "",
  "MaxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListCostAllocationTags")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"Status\": \"\",\n  \"TagKeys\": \"\",\n  \"Type\": \"\",\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=AWSInsightsIndexService.ListCostAllocationTags"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"Status\": \"\",\n  \"TagKeys\": \"\",\n  \"Type\": \"\",\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  \"Status\": \"\",\n  \"TagKeys\": \"\",\n  \"Type\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListCostAllocationTags")
  .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=AWSInsightsIndexService.ListCostAllocationTags")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"Status\": \"\",\n  \"TagKeys\": \"\",\n  \"Type\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  Status: '',
  TagKeys: '',
  Type: '',
  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=AWSInsightsIndexService.ListCostAllocationTags');
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=AWSInsightsIndexService.ListCostAllocationTags',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Status: '', TagKeys: '', Type: '', NextToken: '', MaxResults: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListCostAllocationTags';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Status":"","TagKeys":"","Type":"","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=AWSInsightsIndexService.ListCostAllocationTags',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Status": "",\n  "TagKeys": "",\n  "Type": "",\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  \"Status\": \"\",\n  \"TagKeys\": \"\",\n  \"Type\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListCostAllocationTags")
  .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({Status: '', TagKeys: '', Type: '', NextToken: '', MaxResults: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  Status: '',
  TagKeys: '',
  Type: '',
  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=AWSInsightsIndexService.ListCostAllocationTags',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Status: '', TagKeys: '', Type: '', 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=AWSInsightsIndexService.ListCostAllocationTags';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"Status":"","TagKeys":"","Type":"","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 = @{ @"Status": @"",
                              @"TagKeys": @"",
                              @"Type": @"",
                              @"NextToken": @"",
                              @"MaxResults": @"" };

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'Status' => '',
  'TagKeys' => '',
  'Type' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));

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

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

append(json_encode([
  'Status' => '',
  'TagKeys' => '',
  'Type' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListCostAllocationTags');
$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=AWSInsightsIndexService.ListCostAllocationTags' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Status": "",
  "TagKeys": "",
  "Type": "",
  "NextToken": "",
  "MaxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListCostAllocationTags' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "Status": "",
  "TagKeys": "",
  "Type": "",
  "NextToken": "",
  "MaxResults": ""
}'

import http.client

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

payload = "{\n  \"Status\": \"\",\n  \"TagKeys\": \"\",\n  \"Type\": \"\",\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=AWSInsightsIndexService.ListCostAllocationTags"

payload = {
    "Status": "",
    "TagKeys": "",
    "Type": "",
    "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=AWSInsightsIndexService.ListCostAllocationTags"

payload <- "{\n  \"Status\": \"\",\n  \"TagKeys\": \"\",\n  \"Type\": \"\",\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=AWSInsightsIndexService.ListCostAllocationTags")

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  \"Status\": \"\",\n  \"TagKeys\": \"\",\n  \"Type\": \"\",\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  \"Status\": \"\",\n  \"TagKeys\": \"\",\n  \"Type\": \"\",\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=AWSInsightsIndexService.ListCostAllocationTags";

    let payload = json!({
        "Status": "",
        "TagKeys": "",
        "Type": "",
        "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=AWSInsightsIndexService.ListCostAllocationTags' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Status": "",
  "TagKeys": "",
  "Type": "",
  "NextToken": "",
  "MaxResults": ""
}'

echo '{
  "Status": "",
  "TagKeys": "",
  "Type": "",
  "NextToken": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListCostAllocationTags' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "Status": "",\n  "TagKeys": "",\n  "Type": "",\n  "NextToken": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListCostAllocationTags'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "Status": "",
  "TagKeys": "",
  "Type": "",
  "NextToken": "",
  "MaxResults": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListCostCategoryDefinitions

HEADERS

X-Amz-Target

BODY json

{
  "EffectiveOn": "",
  "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=AWSInsightsIndexService.ListCostCategoryDefinitions");

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  \"EffectiveOn\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListCostCategoryDefinitions" {:headers {:x-amz-target ""}
                                                                                                              :content-type :json
                                                                                                              :form-params {:EffectiveOn ""
                                                                                                                            :NextToken ""
                                                                                                                            :MaxResults ""}})

require "http/client"

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

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

{
  "EffectiveOn": "",
  "NextToken": "",
  "MaxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListCostCategoryDefinitions")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"EffectiveOn\": \"\",\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=AWSInsightsIndexService.ListCostCategoryDefinitions"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"EffectiveOn\": \"\",\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  \"EffectiveOn\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListCostCategoryDefinitions")
  .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=AWSInsightsIndexService.ListCostCategoryDefinitions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"EffectiveOn\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  EffectiveOn: '',
  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=AWSInsightsIndexService.ListCostCategoryDefinitions');
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=AWSInsightsIndexService.ListCostCategoryDefinitions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {EffectiveOn: '', NextToken: '', MaxResults: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListCostCategoryDefinitions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EffectiveOn":"","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=AWSInsightsIndexService.ListCostCategoryDefinitions',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "EffectiveOn": "",\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  \"EffectiveOn\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListCostCategoryDefinitions")
  .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({EffectiveOn: '', NextToken: '', MaxResults: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  EffectiveOn: '',
  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=AWSInsightsIndexService.ListCostCategoryDefinitions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {EffectiveOn: '', 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=AWSInsightsIndexService.ListCostCategoryDefinitions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"EffectiveOn":"","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 = @{ @"EffectiveOn": @"",
                              @"NextToken": @"",
                              @"MaxResults": @"" };

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'EffectiveOn' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));

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

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

append(json_encode([
  'EffectiveOn' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListCostCategoryDefinitions');
$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=AWSInsightsIndexService.ListCostCategoryDefinitions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "EffectiveOn": "",
  "NextToken": "",
  "MaxResults": ""
}'

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

import http.client

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

payload = "{\n  \"EffectiveOn\": \"\",\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=AWSInsightsIndexService.ListCostCategoryDefinitions"

payload = {
    "EffectiveOn": "",
    "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=AWSInsightsIndexService.ListCostCategoryDefinitions"

payload <- "{\n  \"EffectiveOn\": \"\",\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=AWSInsightsIndexService.ListCostCategoryDefinitions")

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  \"EffectiveOn\": \"\",\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  \"EffectiveOn\": \"\",\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=AWSInsightsIndexService.ListCostCategoryDefinitions";

    let payload = json!({
        "EffectiveOn": "",
        "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=AWSInsightsIndexService.ListCostCategoryDefinitions' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "EffectiveOn": "",
  "NextToken": "",
  "MaxResults": ""
}'

echo '{
  "EffectiveOn": "",
  "NextToken": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListCostCategoryDefinitions' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "EffectiveOn": "",\n  "NextToken": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListCostCategoryDefinitions'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration

HEADERS

X-Amz-Target

BODY json

{
  "GenerationStatus": "",
  "RecommendationIds": "",
  "PageSize": "",
  "NextPageToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"GenerationStatus\": \"\",\n  \"RecommendationIds\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration" {:headers {:x-amz-target ""}
                                                                                                                                   :content-type :json
                                                                                                                                   :form-params {:GenerationStatus ""
                                                                                                                                                 :RecommendationIds ""
                                                                                                                                                 :PageSize ""
                                                                                                                                                 :NextPageToken ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration"

	payload := strings.NewReader("{\n  \"GenerationStatus\": \"\",\n  \"RecommendationIds\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\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: 96

{
  "GenerationStatus": "",
  "RecommendationIds": "",
  "PageSize": "",
  "NextPageToken": ""
}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"GenerationStatus\": \"\",\n  \"RecommendationIds\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\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  \"GenerationStatus\": \"\",\n  \"RecommendationIds\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration")
  .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=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"GenerationStatus\": \"\",\n  \"RecommendationIds\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  GenerationStatus: '',
  RecommendationIds: '',
  PageSize: '',
  NextPageToken: ''
});

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=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration');
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=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GenerationStatus: '', RecommendationIds: '', PageSize: '', NextPageToken: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GenerationStatus":"","RecommendationIds":"","PageSize":"","NextPageToken":""}'
};

try {
  const response = await 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=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "GenerationStatus": "",\n  "RecommendationIds": "",\n  "PageSize": "",\n  "NextPageToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"GenerationStatus\": \"\",\n  \"RecommendationIds\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration")
  .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({GenerationStatus: '', RecommendationIds: '', PageSize: '', NextPageToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {GenerationStatus: '', RecommendationIds: '', PageSize: '', NextPageToken: ''},
  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=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration');

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

req.type('json');
req.send({
  GenerationStatus: '',
  RecommendationIds: '',
  PageSize: '',
  NextPageToken: ''
});

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=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {GenerationStatus: '', RecommendationIds: '', PageSize: '', NextPageToken: ''}
};

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=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"GenerationStatus":"","RecommendationIds":"","PageSize":"","NextPageToken":""}'
};

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 = @{ @"GenerationStatus": @"",
                              @"RecommendationIds": @"",
                              @"PageSize": @"",
                              @"NextPageToken": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration",
  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([
    'GenerationStatus' => '',
    'RecommendationIds' => '',
    'PageSize' => '',
    'NextPageToken' => ''
  ]),
  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=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration', [
  'body' => '{
  "GenerationStatus": "",
  "RecommendationIds": "",
  "PageSize": "",
  "NextPageToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'GenerationStatus' => '',
  'RecommendationIds' => '',
  'PageSize' => '',
  'NextPageToken' => ''
]));

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

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

append(json_encode([
  'GenerationStatus' => '',
  'RecommendationIds' => '',
  'PageSize' => '',
  'NextPageToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration');
$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=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GenerationStatus": "",
  "RecommendationIds": "",
  "PageSize": "",
  "NextPageToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "GenerationStatus": "",
  "RecommendationIds": "",
  "PageSize": "",
  "NextPageToken": ""
}'

import http.client

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

payload = "{\n  \"GenerationStatus\": \"\",\n  \"RecommendationIds\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration"

payload = {
    "GenerationStatus": "",
    "RecommendationIds": "",
    "PageSize": "",
    "NextPageToken": ""
}
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=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration"

payload <- "{\n  \"GenerationStatus\": \"\",\n  \"RecommendationIds\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration")

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  \"GenerationStatus\": \"\",\n  \"RecommendationIds\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\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  \"GenerationStatus\": \"\",\n  \"RecommendationIds\": \"\",\n  \"PageSize\": \"\",\n  \"NextPageToken\": \"\"\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=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration";

    let payload = json!({
        "GenerationStatus": "",
        "RecommendationIds": "",
        "PageSize": "",
        "NextPageToken": ""
    });

    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=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "GenerationStatus": "",
  "RecommendationIds": "",
  "PageSize": "",
  "NextPageToken": ""
}'

echo '{
  "GenerationStatus": "",
  "RecommendationIds": "",
  "PageSize": "",
  "NextPageToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "GenerationStatus": "",\n  "RecommendationIds": "",\n  "PageSize": "",\n  "NextPageToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListSavingsPlansPurchaseRecommendationGeneration'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListTagsForResource

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=AWSInsightsIndexService.ListTagsForResource");

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListTagsForResource" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:ResourceArn ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListTagsForResource"
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=AWSInsightsIndexService.ListTagsForResource"),
    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=AWSInsightsIndexService.ListTagsForResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ResourceArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListTagsForResource"

	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=AWSInsightsIndexService.ListTagsForResource")
  .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=AWSInsightsIndexService.ListTagsForResource"))
    .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=AWSInsightsIndexService.ListTagsForResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListTagsForResource")
  .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=AWSInsightsIndexService.ListTagsForResource');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListTagsForResource',
  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=AWSInsightsIndexService.ListTagsForResource';
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=AWSInsightsIndexService.ListTagsForResource',
  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=AWSInsightsIndexService.ListTagsForResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListTagsForResource',
  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=AWSInsightsIndexService.ListTagsForResource');

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=AWSInsightsIndexService.ListTagsForResource',
  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=AWSInsightsIndexService.ListTagsForResource';
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=AWSInsightsIndexService.ListTagsForResource"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

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

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListTagsForResource" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ResourceArn\": \"\"\n}" in

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListTagsForResource');
$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=AWSInsightsIndexService.ListTagsForResource');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListTagsForResource' -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=AWSInsightsIndexService.ListTagsForResource' -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=AWSInsightsIndexService.ListTagsForResource"

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=AWSInsightsIndexService.ListTagsForResource"

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=AWSInsightsIndexService.ListTagsForResource")

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

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

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=AWSInsightsIndexService.ListTagsForResource";

    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=AWSInsightsIndexService.ListTagsForResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceArn": ""
}'

echo '{
  "ResourceArn": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ListTagsForResource' \
  content-type:application/json \
  x-amz-target:''

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

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=AWSInsightsIndexService.ListTagsForResource")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

POST ProvideAnomalyFeedback

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ProvideAnomalyFeedback

HEADERS

X-Amz-Target

BODY json

{
  "AnomalyId": "",
  "Feedback": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ProvideAnomalyFeedback" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:AnomalyId ""
                                                                                                                       :Feedback ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ProvideAnomalyFeedback"

	payload := strings.NewReader("{\n  \"AnomalyId\": \"\",\n  \"Feedback\": \"\"\n}")

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

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

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

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

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

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 39

{
  "AnomalyId": "",
  "Feedback": ""
}

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

client.close();

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

const data = JSON.stringify({
  AnomalyId: '',
  Feedback: ''
});

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=AWSInsightsIndexService.ProvideAnomalyFeedback');
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=AWSInsightsIndexService.ProvideAnomalyFeedback',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AnomalyId: '', Feedback: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ProvideAnomalyFeedback';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AnomalyId":"","Feedback":""}'
};

try {
  const response = await 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=AWSInsightsIndexService.ProvideAnomalyFeedback',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "AnomalyId": "",\n  "Feedback": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"AnomalyId\": \"\",\n  \"Feedback\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ProvideAnomalyFeedback")
  .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({AnomalyId: '', Feedback: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  AnomalyId: '',
  Feedback: ''
});

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=AWSInsightsIndexService.ProvideAnomalyFeedback',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {AnomalyId: '', Feedback: ''}
};

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=AWSInsightsIndexService.ProvideAnomalyFeedback';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"AnomalyId":"","Feedback":""}'
};

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ProvideAnomalyFeedback",
  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([
    'AnomalyId' => '',
    'Feedback' => ''
  ]),
  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=AWSInsightsIndexService.ProvideAnomalyFeedback', [
  'body' => '{
  "AnomalyId": "",
  "Feedback": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'AnomalyId' => '',
  'Feedback' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ProvideAnomalyFeedback');
$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=AWSInsightsIndexService.ProvideAnomalyFeedback' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "AnomalyId": "",
  "Feedback": ""
}'

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

import http.client

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

payload = "{\n  \"AnomalyId\": \"\",\n  \"Feedback\": \"\"\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=AWSInsightsIndexService.ProvideAnomalyFeedback"

payload = {
    "AnomalyId": "",
    "Feedback": ""
}
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=AWSInsightsIndexService.ProvideAnomalyFeedback"

payload <- "{\n  \"AnomalyId\": \"\",\n  \"Feedback\": \"\"\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=AWSInsightsIndexService.ProvideAnomalyFeedback")

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  \"AnomalyId\": \"\",\n  \"Feedback\": \"\"\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  \"AnomalyId\": \"\",\n  \"Feedback\": \"\"\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=AWSInsightsIndexService.ProvideAnomalyFeedback";

    let payload = json!({
        "AnomalyId": "",
        "Feedback": ""
    });

    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=AWSInsightsIndexService.ProvideAnomalyFeedback' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "AnomalyId": "",
  "Feedback": ""
}'

echo '{
  "AnomalyId": "",
  "Feedback": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.ProvideAnomalyFeedback' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.StartSavingsPlansPurchaseRecommendationGeneration

HEADERS

X-Amz-Target

BODY json

{}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.StartSavingsPlansPurchaseRecommendationGeneration" {:headers {:x-amz-target ""}
                                                                                                                                    :content-type :json})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.StartSavingsPlansPurchaseRecommendationGeneration"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{}"

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=AWSInsightsIndexService.StartSavingsPlansPurchaseRecommendationGeneration"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{}")
    {
        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=AWSInsightsIndexService.StartSavingsPlansPurchaseRecommendationGeneration");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.StartSavingsPlansPurchaseRecommendationGeneration"

	payload := strings.NewReader("{}")

	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: 2

{}

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

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.StartSavingsPlansPurchaseRecommendationGeneration"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{}"))
    .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, "{}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.StartSavingsPlansPurchaseRecommendationGeneration")
  .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=AWSInsightsIndexService.StartSavingsPlansPurchaseRecommendationGeneration")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{}")
  .asString();

const data = JSON.stringify({});

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=AWSInsightsIndexService.StartSavingsPlansPurchaseRecommendationGeneration');
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=AWSInsightsIndexService.StartSavingsPlansPurchaseRecommendationGeneration',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {}
};

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

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

try {
  const response = await 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=AWSInsightsIndexService.StartSavingsPlansPurchaseRecommendationGeneration',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.StartSavingsPlansPurchaseRecommendationGeneration")
  .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({}));
req.end();

const request = require('request');

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

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

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

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=AWSInsightsIndexService.StartSavingsPlansPurchaseRecommendationGeneration',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {}
};

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=AWSInsightsIndexService.StartSavingsPlansPurchaseRecommendationGeneration';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{}'
};

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.StartSavingsPlansPurchaseRecommendationGeneration",
  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([
    
  ]),
  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=AWSInsightsIndexService.StartSavingsPlansPurchaseRecommendationGeneration', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.StartSavingsPlansPurchaseRecommendationGeneration');
$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=AWSInsightsIndexService.StartSavingsPlansPurchaseRecommendationGeneration' -Method POST -Headers $headers -ContentType 'application/json' -Body '{}'

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

import http.client

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

payload = "{}"

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=AWSInsightsIndexService.StartSavingsPlansPurchaseRecommendationGeneration"

payload = {}
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=AWSInsightsIndexService.StartSavingsPlansPurchaseRecommendationGeneration"

payload <- "{}"

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=AWSInsightsIndexService.StartSavingsPlansPurchaseRecommendationGeneration")

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

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 = "{}"
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=AWSInsightsIndexService.StartSavingsPlansPurchaseRecommendationGeneration";

    let payload = json!({});

    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=AWSInsightsIndexService.StartSavingsPlansPurchaseRecommendationGeneration' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{}'

echo '{}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.StartSavingsPlansPurchaseRecommendationGeneration' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.StartSavingsPlansPurchaseRecommendationGeneration'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.TagResource

HEADERS

X-Amz-Target

BODY json

{
  "ResourceArn": "",
  "ResourceTags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.TagResource" {:headers {:x-amz-target ""}
                                                                                              :content-type :json
                                                                                              :form-params {:ResourceArn ""
                                                                                                            :ResourceTags ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.TagResource"

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

{
  "ResourceArn": "",
  "ResourceTags": ""
}

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

client.close();

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

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

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=AWSInsightsIndexService.TagResource');
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=AWSInsightsIndexService.TagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: '', ResourceTags: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.TagResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":"","ResourceTags":""}'
};

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

const request = require('request');

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

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

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

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=AWSInsightsIndexService.TagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: '', ResourceTags: ''}
};

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=AWSInsightsIndexService.TagResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":"","ResourceTags":""}'
};

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.TagResource"]
                                                       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=AWSInsightsIndexService.TagResource" 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  \"ResourceTags\": \"\"\n}" in

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"ResourceArn\": \"\",\n  \"ResourceTags\": \"\"\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=AWSInsightsIndexService.TagResource"

payload = {
    "ResourceArn": "",
    "ResourceTags": ""
}
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=AWSInsightsIndexService.TagResource"

payload <- "{\n  \"ResourceArn\": \"\",\n  \"ResourceTags\": \"\"\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=AWSInsightsIndexService.TagResource")

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  \"ResourceTags\": \"\"\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  \"ResourceTags\": \"\"\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=AWSInsightsIndexService.TagResource";

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

    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=AWSInsightsIndexService.TagResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceArn": "",
  "ResourceTags": ""
}'

echo '{
  "ResourceArn": "",
  "ResourceTags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.TagResource' \
  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  "ResourceTags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.TagResource'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UntagResource

HEADERS

X-Amz-Target

BODY json

{
  "ResourceArn": "",
  "ResourceTagKeys": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UntagResource" {:headers {:x-amz-target ""}
                                                                                                :content-type :json
                                                                                                :form-params {:ResourceArn ""
                                                                                                              :ResourceTagKeys ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UntagResource"

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

{
  "ResourceArn": "",
  "ResourceTagKeys": ""
}

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

client.close();

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

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

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=AWSInsightsIndexService.UntagResource');
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=AWSInsightsIndexService.UntagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: '', ResourceTagKeys: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UntagResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":"","ResourceTagKeys":""}'
};

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

const request = require('request');

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

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

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

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=AWSInsightsIndexService.UntagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ResourceArn: '', ResourceTagKeys: ''}
};

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=AWSInsightsIndexService.UntagResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceArn":"","ResourceTagKeys":""}'
};

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UntagResource"]
                                                       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=AWSInsightsIndexService.UntagResource" 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  \"ResourceTagKeys\": \"\"\n}" in

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"ResourceArn\": \"\",\n  \"ResourceTagKeys\": \"\"\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=AWSInsightsIndexService.UntagResource"

payload = {
    "ResourceArn": "",
    "ResourceTagKeys": ""
}
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=AWSInsightsIndexService.UntagResource"

payload <- "{\n  \"ResourceArn\": \"\",\n  \"ResourceTagKeys\": \"\"\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=AWSInsightsIndexService.UntagResource")

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  \"ResourceTagKeys\": \"\"\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  \"ResourceTagKeys\": \"\"\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=AWSInsightsIndexService.UntagResource";

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

    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=AWSInsightsIndexService.UntagResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceArn": "",
  "ResourceTagKeys": ""
}'

echo '{
  "ResourceArn": "",
  "ResourceTagKeys": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UntagResource' \
  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  "ResourceTagKeys": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UntagResource'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateAnomalyMonitor

HEADERS

X-Amz-Target

BODY json

{
  "MonitorArn": "",
  "MonitorName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateAnomalyMonitor" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:MonitorArn ""
                                                                                                                     :MonitorName ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateAnomalyMonitor"

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

{
  "MonitorArn": "",
  "MonitorName": ""
}

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

client.close();

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

const data = JSON.stringify({
  MonitorArn: '',
  MonitorName: ''
});

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=AWSInsightsIndexService.UpdateAnomalyMonitor');
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=AWSInsightsIndexService.UpdateAnomalyMonitor',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {MonitorArn: '', MonitorName: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateAnomalyMonitor';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"MonitorArn":"","MonitorName":""}'
};

try {
  const response = await 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=AWSInsightsIndexService.UpdateAnomalyMonitor',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "MonitorArn": "",\n  "MonitorName": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"MonitorArn\": \"\",\n  \"MonitorName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateAnomalyMonitor")
  .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({MonitorArn: '', MonitorName: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  MonitorArn: '',
  MonitorName: ''
});

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=AWSInsightsIndexService.UpdateAnomalyMonitor',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {MonitorArn: '', MonitorName: ''}
};

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=AWSInsightsIndexService.UpdateAnomalyMonitor';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"MonitorArn":"","MonitorName":""}'
};

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateAnomalyMonitor",
  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([
    'MonitorArn' => '',
    'MonitorName' => ''
  ]),
  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=AWSInsightsIndexService.UpdateAnomalyMonitor', [
  'body' => '{
  "MonitorArn": "",
  "MonitorName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'MonitorArn' => '',
  'MonitorName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateAnomalyMonitor');
$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=AWSInsightsIndexService.UpdateAnomalyMonitor' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "MonitorArn": "",
  "MonitorName": ""
}'

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

import http.client

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

payload = "{\n  \"MonitorArn\": \"\",\n  \"MonitorName\": \"\"\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=AWSInsightsIndexService.UpdateAnomalyMonitor"

payload = {
    "MonitorArn": "",
    "MonitorName": ""
}
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=AWSInsightsIndexService.UpdateAnomalyMonitor"

payload <- "{\n  \"MonitorArn\": \"\",\n  \"MonitorName\": \"\"\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=AWSInsightsIndexService.UpdateAnomalyMonitor")

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  \"MonitorArn\": \"\",\n  \"MonitorName\": \"\"\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  \"MonitorArn\": \"\",\n  \"MonitorName\": \"\"\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=AWSInsightsIndexService.UpdateAnomalyMonitor";

    let payload = json!({
        "MonitorArn": "",
        "MonitorName": ""
    });

    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=AWSInsightsIndexService.UpdateAnomalyMonitor' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "MonitorArn": "",
  "MonitorName": ""
}'

echo '{
  "MonitorArn": "",
  "MonitorName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateAnomalyMonitor' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateAnomalySubscription

HEADERS

X-Amz-Target

BODY json

{
  "SubscriptionArn": "",
  "Threshold": "",
  "Frequency": "",
  "MonitorArnList": "",
  "Subscribers": "",
  "SubscriptionName": "",
  "ThresholdExpression": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"SubscriptionArn\": \"\",\n  \"Threshold\": \"\",\n  \"Frequency\": \"\",\n  \"MonitorArnList\": \"\",\n  \"Subscribers\": \"\",\n  \"SubscriptionName\": \"\",\n  \"ThresholdExpression\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateAnomalySubscription" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:SubscriptionArn ""
                                                                                                                          :Threshold ""
                                                                                                                          :Frequency ""
                                                                                                                          :MonitorArnList ""
                                                                                                                          :Subscribers ""
                                                                                                                          :SubscriptionName ""
                                                                                                                          :ThresholdExpression ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateAnomalySubscription"

	payload := strings.NewReader("{\n  \"SubscriptionArn\": \"\",\n  \"Threshold\": \"\",\n  \"Frequency\": \"\",\n  \"MonitorArnList\": \"\",\n  \"Subscribers\": \"\",\n  \"SubscriptionName\": \"\",\n  \"ThresholdExpression\": \"\"\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: 165

{
  "SubscriptionArn": "",
  "Threshold": "",
  "Frequency": "",
  "MonitorArnList": "",
  "Subscribers": "",
  "SubscriptionName": "",
  "ThresholdExpression": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateAnomalySubscription")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"SubscriptionArn\": \"\",\n  \"Threshold\": \"\",\n  \"Frequency\": \"\",\n  \"MonitorArnList\": \"\",\n  \"Subscribers\": \"\",\n  \"SubscriptionName\": \"\",\n  \"ThresholdExpression\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateAnomalySubscription"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"SubscriptionArn\": \"\",\n  \"Threshold\": \"\",\n  \"Frequency\": \"\",\n  \"MonitorArnList\": \"\",\n  \"Subscribers\": \"\",\n  \"SubscriptionName\": \"\",\n  \"ThresholdExpression\": \"\"\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  \"SubscriptionArn\": \"\",\n  \"Threshold\": \"\",\n  \"Frequency\": \"\",\n  \"MonitorArnList\": \"\",\n  \"Subscribers\": \"\",\n  \"SubscriptionName\": \"\",\n  \"ThresholdExpression\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateAnomalySubscription")
  .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=AWSInsightsIndexService.UpdateAnomalySubscription")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"SubscriptionArn\": \"\",\n  \"Threshold\": \"\",\n  \"Frequency\": \"\",\n  \"MonitorArnList\": \"\",\n  \"Subscribers\": \"\",\n  \"SubscriptionName\": \"\",\n  \"ThresholdExpression\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  SubscriptionArn: '',
  Threshold: '',
  Frequency: '',
  MonitorArnList: '',
  Subscribers: '',
  SubscriptionName: '',
  ThresholdExpression: ''
});

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=AWSInsightsIndexService.UpdateAnomalySubscription');
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=AWSInsightsIndexService.UpdateAnomalySubscription',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    SubscriptionArn: '',
    Threshold: '',
    Frequency: '',
    MonitorArnList: '',
    Subscribers: '',
    SubscriptionName: '',
    ThresholdExpression: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateAnomalySubscription';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SubscriptionArn":"","Threshold":"","Frequency":"","MonitorArnList":"","Subscribers":"","SubscriptionName":"","ThresholdExpression":""}'
};

try {
  const response = await 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=AWSInsightsIndexService.UpdateAnomalySubscription',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "SubscriptionArn": "",\n  "Threshold": "",\n  "Frequency": "",\n  "MonitorArnList": "",\n  "Subscribers": "",\n  "SubscriptionName": "",\n  "ThresholdExpression": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"SubscriptionArn\": \"\",\n  \"Threshold\": \"\",\n  \"Frequency\": \"\",\n  \"MonitorArnList\": \"\",\n  \"Subscribers\": \"\",\n  \"SubscriptionName\": \"\",\n  \"ThresholdExpression\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateAnomalySubscription")
  .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({
  SubscriptionArn: '',
  Threshold: '',
  Frequency: '',
  MonitorArnList: '',
  Subscribers: '',
  SubscriptionName: '',
  ThresholdExpression: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateAnomalySubscription',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    SubscriptionArn: '',
    Threshold: '',
    Frequency: '',
    MonitorArnList: '',
    Subscribers: '',
    SubscriptionName: '',
    ThresholdExpression: ''
  },
  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=AWSInsightsIndexService.UpdateAnomalySubscription');

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

req.type('json');
req.send({
  SubscriptionArn: '',
  Threshold: '',
  Frequency: '',
  MonitorArnList: '',
  Subscribers: '',
  SubscriptionName: '',
  ThresholdExpression: ''
});

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=AWSInsightsIndexService.UpdateAnomalySubscription',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    SubscriptionArn: '',
    Threshold: '',
    Frequency: '',
    MonitorArnList: '',
    Subscribers: '',
    SubscriptionName: '',
    ThresholdExpression: ''
  }
};

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=AWSInsightsIndexService.UpdateAnomalySubscription';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"SubscriptionArn":"","Threshold":"","Frequency":"","MonitorArnList":"","Subscribers":"","SubscriptionName":"","ThresholdExpression":""}'
};

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 = @{ @"SubscriptionArn": @"",
                              @"Threshold": @"",
                              @"Frequency": @"",
                              @"MonitorArnList": @"",
                              @"Subscribers": @"",
                              @"SubscriptionName": @"",
                              @"ThresholdExpression": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateAnomalySubscription"]
                                                       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=AWSInsightsIndexService.UpdateAnomalySubscription" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"SubscriptionArn\": \"\",\n  \"Threshold\": \"\",\n  \"Frequency\": \"\",\n  \"MonitorArnList\": \"\",\n  \"Subscribers\": \"\",\n  \"SubscriptionName\": \"\",\n  \"ThresholdExpression\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateAnomalySubscription",
  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([
    'SubscriptionArn' => '',
    'Threshold' => '',
    'Frequency' => '',
    'MonitorArnList' => '',
    'Subscribers' => '',
    'SubscriptionName' => '',
    'ThresholdExpression' => ''
  ]),
  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=AWSInsightsIndexService.UpdateAnomalySubscription', [
  'body' => '{
  "SubscriptionArn": "",
  "Threshold": "",
  "Frequency": "",
  "MonitorArnList": "",
  "Subscribers": "",
  "SubscriptionName": "",
  "ThresholdExpression": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'SubscriptionArn' => '',
  'Threshold' => '',
  'Frequency' => '',
  'MonitorArnList' => '',
  'Subscribers' => '',
  'SubscriptionName' => '',
  'ThresholdExpression' => ''
]));

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

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

append(json_encode([
  'SubscriptionArn' => '',
  'Threshold' => '',
  'Frequency' => '',
  'MonitorArnList' => '',
  'Subscribers' => '',
  'SubscriptionName' => '',
  'ThresholdExpression' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateAnomalySubscription');
$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=AWSInsightsIndexService.UpdateAnomalySubscription' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SubscriptionArn": "",
  "Threshold": "",
  "Frequency": "",
  "MonitorArnList": "",
  "Subscribers": "",
  "SubscriptionName": "",
  "ThresholdExpression": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateAnomalySubscription' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "SubscriptionArn": "",
  "Threshold": "",
  "Frequency": "",
  "MonitorArnList": "",
  "Subscribers": "",
  "SubscriptionName": "",
  "ThresholdExpression": ""
}'

import http.client

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

payload = "{\n  \"SubscriptionArn\": \"\",\n  \"Threshold\": \"\",\n  \"Frequency\": \"\",\n  \"MonitorArnList\": \"\",\n  \"Subscribers\": \"\",\n  \"SubscriptionName\": \"\",\n  \"ThresholdExpression\": \"\"\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=AWSInsightsIndexService.UpdateAnomalySubscription"

payload = {
    "SubscriptionArn": "",
    "Threshold": "",
    "Frequency": "",
    "MonitorArnList": "",
    "Subscribers": "",
    "SubscriptionName": "",
    "ThresholdExpression": ""
}
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=AWSInsightsIndexService.UpdateAnomalySubscription"

payload <- "{\n  \"SubscriptionArn\": \"\",\n  \"Threshold\": \"\",\n  \"Frequency\": \"\",\n  \"MonitorArnList\": \"\",\n  \"Subscribers\": \"\",\n  \"SubscriptionName\": \"\",\n  \"ThresholdExpression\": \"\"\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=AWSInsightsIndexService.UpdateAnomalySubscription")

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  \"SubscriptionArn\": \"\",\n  \"Threshold\": \"\",\n  \"Frequency\": \"\",\n  \"MonitorArnList\": \"\",\n  \"Subscribers\": \"\",\n  \"SubscriptionName\": \"\",\n  \"ThresholdExpression\": \"\"\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  \"SubscriptionArn\": \"\",\n  \"Threshold\": \"\",\n  \"Frequency\": \"\",\n  \"MonitorArnList\": \"\",\n  \"Subscribers\": \"\",\n  \"SubscriptionName\": \"\",\n  \"ThresholdExpression\": \"\"\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=AWSInsightsIndexService.UpdateAnomalySubscription";

    let payload = json!({
        "SubscriptionArn": "",
        "Threshold": "",
        "Frequency": "",
        "MonitorArnList": "",
        "Subscribers": "",
        "SubscriptionName": "",
        "ThresholdExpression": ""
    });

    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=AWSInsightsIndexService.UpdateAnomalySubscription' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "SubscriptionArn": "",
  "Threshold": "",
  "Frequency": "",
  "MonitorArnList": "",
  "Subscribers": "",
  "SubscriptionName": "",
  "ThresholdExpression": ""
}'

echo '{
  "SubscriptionArn": "",
  "Threshold": "",
  "Frequency": "",
  "MonitorArnList": "",
  "Subscribers": "",
  "SubscriptionName": "",
  "ThresholdExpression": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateAnomalySubscription' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "SubscriptionArn": "",\n  "Threshold": "",\n  "Frequency": "",\n  "MonitorArnList": "",\n  "Subscribers": "",\n  "SubscriptionName": "",\n  "ThresholdExpression": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateAnomalySubscription'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "SubscriptionArn": "",
  "Threshold": "",
  "Frequency": "",
  "MonitorArnList": "",
  "Subscribers": "",
  "SubscriptionName": "",
  "ThresholdExpression": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateCostAllocationTagsStatus

HEADERS

X-Amz-Target

BODY json

{
  "CostAllocationTagsStatus": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateCostAllocationTagsStatus" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:CostAllocationTagsStatus ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateCostAllocationTagsStatus"

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

{
  "CostAllocationTagsStatus": ""
}

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

client.close();

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

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

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=AWSInsightsIndexService.UpdateCostAllocationTagsStatus');
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=AWSInsightsIndexService.UpdateCostAllocationTagsStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CostAllocationTagsStatus: ''}
};

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

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

try {
  const response = await 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=AWSInsightsIndexService.UpdateCostAllocationTagsStatus',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CostAllocationTagsStatus": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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=AWSInsightsIndexService.UpdateCostAllocationTagsStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {CostAllocationTagsStatus: ''}
};

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=AWSInsightsIndexService.UpdateCostAllocationTagsStatus';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CostAllocationTagsStatus":""}'
};

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateCostAllocationTagsStatus",
  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([
    'CostAllocationTagsStatus' => ''
  ]),
  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=AWSInsightsIndexService.UpdateCostAllocationTagsStatus', [
  'body' => '{
  "CostAllocationTagsStatus": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'CostAllocationTagsStatus' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateCostAllocationTagsStatus');
$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=AWSInsightsIndexService.UpdateCostAllocationTagsStatus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CostAllocationTagsStatus": ""
}'

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

import http.client

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

payload = "{\n  \"CostAllocationTagsStatus\": \"\"\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=AWSInsightsIndexService.UpdateCostAllocationTagsStatus"

payload = { "CostAllocationTagsStatus": "" }
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=AWSInsightsIndexService.UpdateCostAllocationTagsStatus"

payload <- "{\n  \"CostAllocationTagsStatus\": \"\"\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=AWSInsightsIndexService.UpdateCostAllocationTagsStatus")

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  \"CostAllocationTagsStatus\": \"\"\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  \"CostAllocationTagsStatus\": \"\"\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=AWSInsightsIndexService.UpdateCostAllocationTagsStatus";

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

    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=AWSInsightsIndexService.UpdateCostAllocationTagsStatus' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "CostAllocationTagsStatus": ""
}'

echo '{
  "CostAllocationTagsStatus": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateCostAllocationTagsStatus' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateCostCategoryDefinition

HEADERS

X-Amz-Target

BODY json

{
  "CostCategoryArn": "",
  "EffectiveStart": "",
  "RuleVersion": "",
  "Rules": "",
  "DefaultValue": "",
  "SplitChargeRules": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"CostCategoryArn\": \"\",\n  \"EffectiveStart\": \"\",\n  \"RuleVersion\": \"\",\n  \"Rules\": \"\",\n  \"DefaultValue\": \"\",\n  \"SplitChargeRules\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateCostCategoryDefinition" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:CostCategoryArn ""
                                                                                                                             :EffectiveStart ""
                                                                                                                             :RuleVersion ""
                                                                                                                             :Rules ""
                                                                                                                             :DefaultValue ""
                                                                                                                             :SplitChargeRules ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateCostCategoryDefinition"

	payload := strings.NewReader("{\n  \"CostCategoryArn\": \"\",\n  \"EffectiveStart\": \"\",\n  \"RuleVersion\": \"\",\n  \"Rules\": \"\",\n  \"DefaultValue\": \"\",\n  \"SplitChargeRules\": \"\"\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: 135

{
  "CostCategoryArn": "",
  "EffectiveStart": "",
  "RuleVersion": "",
  "Rules": "",
  "DefaultValue": "",
  "SplitChargeRules": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateCostCategoryDefinition")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"CostCategoryArn\": \"\",\n  \"EffectiveStart\": \"\",\n  \"RuleVersion\": \"\",\n  \"Rules\": \"\",\n  \"DefaultValue\": \"\",\n  \"SplitChargeRules\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateCostCategoryDefinition"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"CostCategoryArn\": \"\",\n  \"EffectiveStart\": \"\",\n  \"RuleVersion\": \"\",\n  \"Rules\": \"\",\n  \"DefaultValue\": \"\",\n  \"SplitChargeRules\": \"\"\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  \"CostCategoryArn\": \"\",\n  \"EffectiveStart\": \"\",\n  \"RuleVersion\": \"\",\n  \"Rules\": \"\",\n  \"DefaultValue\": \"\",\n  \"SplitChargeRules\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateCostCategoryDefinition")
  .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=AWSInsightsIndexService.UpdateCostCategoryDefinition")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"CostCategoryArn\": \"\",\n  \"EffectiveStart\": \"\",\n  \"RuleVersion\": \"\",\n  \"Rules\": \"\",\n  \"DefaultValue\": \"\",\n  \"SplitChargeRules\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  CostCategoryArn: '',
  EffectiveStart: '',
  RuleVersion: '',
  Rules: '',
  DefaultValue: '',
  SplitChargeRules: ''
});

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=AWSInsightsIndexService.UpdateCostCategoryDefinition');
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=AWSInsightsIndexService.UpdateCostCategoryDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    CostCategoryArn: '',
    EffectiveStart: '',
    RuleVersion: '',
    Rules: '',
    DefaultValue: '',
    SplitChargeRules: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateCostCategoryDefinition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CostCategoryArn":"","EffectiveStart":"","RuleVersion":"","Rules":"","DefaultValue":"","SplitChargeRules":""}'
};

try {
  const response = await 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=AWSInsightsIndexService.UpdateCostCategoryDefinition',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "CostCategoryArn": "",\n  "EffectiveStart": "",\n  "RuleVersion": "",\n  "Rules": "",\n  "DefaultValue": "",\n  "SplitChargeRules": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"CostCategoryArn\": \"\",\n  \"EffectiveStart\": \"\",\n  \"RuleVersion\": \"\",\n  \"Rules\": \"\",\n  \"DefaultValue\": \"\",\n  \"SplitChargeRules\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateCostCategoryDefinition")
  .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({
  CostCategoryArn: '',
  EffectiveStart: '',
  RuleVersion: '',
  Rules: '',
  DefaultValue: '',
  SplitChargeRules: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateCostCategoryDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    CostCategoryArn: '',
    EffectiveStart: '',
    RuleVersion: '',
    Rules: '',
    DefaultValue: '',
    SplitChargeRules: ''
  },
  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=AWSInsightsIndexService.UpdateCostCategoryDefinition');

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

req.type('json');
req.send({
  CostCategoryArn: '',
  EffectiveStart: '',
  RuleVersion: '',
  Rules: '',
  DefaultValue: '',
  SplitChargeRules: ''
});

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=AWSInsightsIndexService.UpdateCostCategoryDefinition',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    CostCategoryArn: '',
    EffectiveStart: '',
    RuleVersion: '',
    Rules: '',
    DefaultValue: '',
    SplitChargeRules: ''
  }
};

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=AWSInsightsIndexService.UpdateCostCategoryDefinition';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"CostCategoryArn":"","EffectiveStart":"","RuleVersion":"","Rules":"","DefaultValue":"","SplitChargeRules":""}'
};

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 = @{ @"CostCategoryArn": @"",
                              @"EffectiveStart": @"",
                              @"RuleVersion": @"",
                              @"Rules": @"",
                              @"DefaultValue": @"",
                              @"SplitChargeRules": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateCostCategoryDefinition",
  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([
    'CostCategoryArn' => '',
    'EffectiveStart' => '',
    'RuleVersion' => '',
    'Rules' => '',
    'DefaultValue' => '',
    'SplitChargeRules' => ''
  ]),
  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=AWSInsightsIndexService.UpdateCostCategoryDefinition', [
  'body' => '{
  "CostCategoryArn": "",
  "EffectiveStart": "",
  "RuleVersion": "",
  "Rules": "",
  "DefaultValue": "",
  "SplitChargeRules": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'CostCategoryArn' => '',
  'EffectiveStart' => '',
  'RuleVersion' => '',
  'Rules' => '',
  'DefaultValue' => '',
  'SplitChargeRules' => ''
]));

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

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

append(json_encode([
  'CostCategoryArn' => '',
  'EffectiveStart' => '',
  'RuleVersion' => '',
  'Rules' => '',
  'DefaultValue' => '',
  'SplitChargeRules' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateCostCategoryDefinition');
$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=AWSInsightsIndexService.UpdateCostCategoryDefinition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CostCategoryArn": "",
  "EffectiveStart": "",
  "RuleVersion": "",
  "Rules": "",
  "DefaultValue": "",
  "SplitChargeRules": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateCostCategoryDefinition' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "CostCategoryArn": "",
  "EffectiveStart": "",
  "RuleVersion": "",
  "Rules": "",
  "DefaultValue": "",
  "SplitChargeRules": ""
}'

import http.client

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

payload = "{\n  \"CostCategoryArn\": \"\",\n  \"EffectiveStart\": \"\",\n  \"RuleVersion\": \"\",\n  \"Rules\": \"\",\n  \"DefaultValue\": \"\",\n  \"SplitChargeRules\": \"\"\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=AWSInsightsIndexService.UpdateCostCategoryDefinition"

payload = {
    "CostCategoryArn": "",
    "EffectiveStart": "",
    "RuleVersion": "",
    "Rules": "",
    "DefaultValue": "",
    "SplitChargeRules": ""
}
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=AWSInsightsIndexService.UpdateCostCategoryDefinition"

payload <- "{\n  \"CostCategoryArn\": \"\",\n  \"EffectiveStart\": \"\",\n  \"RuleVersion\": \"\",\n  \"Rules\": \"\",\n  \"DefaultValue\": \"\",\n  \"SplitChargeRules\": \"\"\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=AWSInsightsIndexService.UpdateCostCategoryDefinition")

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  \"CostCategoryArn\": \"\",\n  \"EffectiveStart\": \"\",\n  \"RuleVersion\": \"\",\n  \"Rules\": \"\",\n  \"DefaultValue\": \"\",\n  \"SplitChargeRules\": \"\"\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  \"CostCategoryArn\": \"\",\n  \"EffectiveStart\": \"\",\n  \"RuleVersion\": \"\",\n  \"Rules\": \"\",\n  \"DefaultValue\": \"\",\n  \"SplitChargeRules\": \"\"\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=AWSInsightsIndexService.UpdateCostCategoryDefinition";

    let payload = json!({
        "CostCategoryArn": "",
        "EffectiveStart": "",
        "RuleVersion": "",
        "Rules": "",
        "DefaultValue": "",
        "SplitChargeRules": ""
    });

    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=AWSInsightsIndexService.UpdateCostCategoryDefinition' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "CostCategoryArn": "",
  "EffectiveStart": "",
  "RuleVersion": "",
  "Rules": "",
  "DefaultValue": "",
  "SplitChargeRules": ""
}'

echo '{
  "CostCategoryArn": "",
  "EffectiveStart": "",
  "RuleVersion": "",
  "Rules": "",
  "DefaultValue": "",
  "SplitChargeRules": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateCostCategoryDefinition' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "CostCategoryArn": "",\n  "EffectiveStart": "",\n  "RuleVersion": "",\n  "Rules": "",\n  "DefaultValue": "",\n  "SplitChargeRules": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSInsightsIndexService.UpdateCostCategoryDefinition'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "CostCategoryArn": "",
  "EffectiveStart": "",
  "RuleVersion": "",
  "Rules": "",
  "DefaultValue": "",
  "SplitChargeRules": ""
] as [String : Any]

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

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