AWS Compute Optimizerv2019-11-01

CURL *hnd = curl_easy_init();

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

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  \"resourceType\": \"\",\n  \"scope\": \"\",\n  \"recommendationPreferenceNames\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.DeleteRecommendationPreferences" {:headers {:x-amz-target ""}
                                                                                                                  :content-type :json
                                                                                                                  :form-params {:resourceType ""
                                                                                                                                :scope ""
                                                                                                                                :recommendationPreferenceNames ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.DeleteRecommendationPreferences"

	payload := strings.NewReader("{\n  \"resourceType\": \"\",\n  \"scope\": \"\",\n  \"recommendationPreferenceNames\": \"\"\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: 78

{
  "resourceType": "",
  "scope": "",
  "recommendationPreferenceNames": ""
}

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

client.close();

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

const data = JSON.stringify({
  resourceType: '',
  scope: '',
  recommendationPreferenceNames: ''
});

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=ComputeOptimizerService.DeleteRecommendationPreferences');
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=ComputeOptimizerService.DeleteRecommendationPreferences',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {resourceType: '', scope: '', recommendationPreferenceNames: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.DeleteRecommendationPreferences';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"resourceType":"","scope":"","recommendationPreferenceNames":""}'
};

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  resourceType: '',
  scope: '',
  recommendationPreferenceNames: ''
});

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=ComputeOptimizerService.DeleteRecommendationPreferences',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {resourceType: '', scope: '', recommendationPreferenceNames: ''}
};

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=ComputeOptimizerService.DeleteRecommendationPreferences';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"resourceType":"","scope":"","recommendationPreferenceNames":""}'
};

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 = @{ @"resourceType": @"",
                              @"scope": @"",
                              @"recommendationPreferenceNames": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resourceType' => '',
  'scope' => '',
  'recommendationPreferenceNames' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"resourceType\": \"\",\n  \"scope\": \"\",\n  \"recommendationPreferenceNames\": \"\"\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=ComputeOptimizerService.DeleteRecommendationPreferences"

payload = {
    "resourceType": "",
    "scope": "",
    "recommendationPreferenceNames": ""
}
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=ComputeOptimizerService.DeleteRecommendationPreferences"

payload <- "{\n  \"resourceType\": \"\",\n  \"scope\": \"\",\n  \"recommendationPreferenceNames\": \"\"\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=ComputeOptimizerService.DeleteRecommendationPreferences")

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  \"resourceType\": \"\",\n  \"scope\": \"\",\n  \"recommendationPreferenceNames\": \"\"\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  \"resourceType\": \"\",\n  \"scope\": \"\",\n  \"recommendationPreferenceNames\": \"\"\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=ComputeOptimizerService.DeleteRecommendationPreferences";

    let payload = json!({
        "resourceType": "",
        "scope": "",
        "recommendationPreferenceNames": ""
    });

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

echo '{
  "resourceType": "",
  "scope": "",
  "recommendationPreferenceNames": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.DeleteRecommendationPreferences' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourceType": "",\n  "scope": "",\n  "recommendationPreferenceNames": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.DeleteRecommendationPreferences'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.DeleteRecommendationPreferences")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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  \"jobIds\": \"\",\n  \"filters\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.DescribeRecommendationExportJobs" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:jobIds ""
                                                                                                                                 :filters ""
                                                                                                                                 :nextToken ""
                                                                                                                                 :maxResults ""}})

require "http/client"

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

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

{
  "jobIds": "",
  "filters": "",
  "nextToken": "",
  "maxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.DescribeRecommendationExportJobs")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"jobIds\": \"\",\n  \"filters\": \"\",\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=ComputeOptimizerService.DescribeRecommendationExportJobs"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"jobIds\": \"\",\n  \"filters\": \"\",\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  \"jobIds\": \"\",\n  \"filters\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.DescribeRecommendationExportJobs")
  .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=ComputeOptimizerService.DescribeRecommendationExportJobs")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"jobIds\": \"\",\n  \"filters\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  jobIds: '',
  filters: '',
  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=ComputeOptimizerService.DescribeRecommendationExportJobs');
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=ComputeOptimizerService.DescribeRecommendationExportJobs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {jobIds: '', filters: '', nextToken: '', maxResults: ''}
};

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

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

const request = require('request');

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

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

req.type('json');
req.send({
  jobIds: '',
  filters: '',
  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=ComputeOptimizerService.DescribeRecommendationExportJobs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {jobIds: '', filters: '', 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=ComputeOptimizerService.DescribeRecommendationExportJobs';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"jobIds":"","filters":"","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 = @{ @"jobIds": @"",
                              @"filters": @"",
                              @"nextToken": @"",
                              @"maxResults": @"" };

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'jobIds' => '',
  'filters' => '',
  'nextToken' => '',
  'maxResults' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"jobIds\": \"\",\n  \"filters\": \"\",\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=ComputeOptimizerService.DescribeRecommendationExportJobs"

payload = {
    "jobIds": "",
    "filters": "",
    "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=ComputeOptimizerService.DescribeRecommendationExportJobs"

payload <- "{\n  \"jobIds\": \"\",\n  \"filters\": \"\",\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=ComputeOptimizerService.DescribeRecommendationExportJobs")

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  \"jobIds\": \"\",\n  \"filters\": \"\",\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  \"jobIds\": \"\",\n  \"filters\": \"\",\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=ComputeOptimizerService.DescribeRecommendationExportJobs";

    let payload = json!({
        "jobIds": "",
        "filters": "",
        "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);
}

echo '{
  "jobIds": "",
  "filters": "",
  "nextToken": "",
  "maxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.DescribeRecommendationExportJobs' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "jobIds": "",\n  "filters": "",\n  "nextToken": "",\n  "maxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.DescribeRecommendationExportJobs'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.DescribeRecommendationExportJobs")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": \"\",\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\",\n  \"recommendationPreferences\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportAutoScalingGroupRecommendations" {:headers {:x-amz-target ""}
                                                                                                                        :content-type :json
                                                                                                                        :form-params {:accountIds ""
                                                                                                                                      :filters ""
                                                                                                                                      :fieldsToExport ""
                                                                                                                                      :s3DestinationConfig ""
                                                                                                                                      :fileFormat ""
                                                                                                                                      :includeMemberAccounts ""
                                                                                                                                      :recommendationPreferences ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportAutoScalingGroupRecommendations"

	payload := strings.NewReader("{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": \"\",\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\",\n  \"recommendationPreferences\": \"\"\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: 178

{
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": "",
  "fileFormat": "",
  "includeMemberAccounts": "",
  "recommendationPreferences": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportAutoScalingGroupRecommendations")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": \"\",\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\",\n  \"recommendationPreferences\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

const data = JSON.stringify({
  accountIds: '',
  filters: '',
  fieldsToExport: '',
  s3DestinationConfig: '',
  fileFormat: '',
  includeMemberAccounts: '',
  recommendationPreferences: ''
});

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=ComputeOptimizerService.ExportAutoScalingGroupRecommendations');
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=ComputeOptimizerService.ExportAutoScalingGroupRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    accountIds: '',
    filters: '',
    fieldsToExport: '',
    s3DestinationConfig: '',
    fileFormat: '',
    includeMemberAccounts: '',
    recommendationPreferences: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportAutoScalingGroupRecommendations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"accountIds":"","filters":"","fieldsToExport":"","s3DestinationConfig":"","fileFormat":"","includeMemberAccounts":"","recommendationPreferences":""}'
};

try {
  const response = await 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=ComputeOptimizerService.ExportAutoScalingGroupRecommendations',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "accountIds": "",\n  "filters": "",\n  "fieldsToExport": "",\n  "s3DestinationConfig": "",\n  "fileFormat": "",\n  "includeMemberAccounts": "",\n  "recommendationPreferences": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": \"\",\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\",\n  \"recommendationPreferences\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportAutoScalingGroupRecommendations")
  .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({
  accountIds: '',
  filters: '',
  fieldsToExport: '',
  s3DestinationConfig: '',
  fileFormat: '',
  includeMemberAccounts: '',
  recommendationPreferences: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportAutoScalingGroupRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    accountIds: '',
    filters: '',
    fieldsToExport: '',
    s3DestinationConfig: '',
    fileFormat: '',
    includeMemberAccounts: '',
    recommendationPreferences: ''
  },
  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=ComputeOptimizerService.ExportAutoScalingGroupRecommendations');

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

req.type('json');
req.send({
  accountIds: '',
  filters: '',
  fieldsToExport: '',
  s3DestinationConfig: '',
  fileFormat: '',
  includeMemberAccounts: '',
  recommendationPreferences: ''
});

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=ComputeOptimizerService.ExportAutoScalingGroupRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    accountIds: '',
    filters: '',
    fieldsToExport: '',
    s3DestinationConfig: '',
    fileFormat: '',
    includeMemberAccounts: '',
    recommendationPreferences: ''
  }
};

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=ComputeOptimizerService.ExportAutoScalingGroupRecommendations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"accountIds":"","filters":"","fieldsToExport":"","s3DestinationConfig":"","fileFormat":"","includeMemberAccounts":"","recommendationPreferences":""}'
};

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 = @{ @"accountIds": @"",
                              @"filters": @"",
                              @"fieldsToExport": @"",
                              @"s3DestinationConfig": @"",
                              @"fileFormat": @"",
                              @"includeMemberAccounts": @"",
                              @"recommendationPreferences": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportAutoScalingGroupRecommendations",
  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([
    'accountIds' => '',
    'filters' => '',
    'fieldsToExport' => '',
    's3DestinationConfig' => '',
    'fileFormat' => '',
    'includeMemberAccounts' => '',
    'recommendationPreferences' => ''
  ]),
  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=ComputeOptimizerService.ExportAutoScalingGroupRecommendations', [
  'body' => '{
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": "",
  "fileFormat": "",
  "includeMemberAccounts": "",
  "recommendationPreferences": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'accountIds' => '',
  'filters' => '',
  'fieldsToExport' => '',
  's3DestinationConfig' => '',
  'fileFormat' => '',
  'includeMemberAccounts' => '',
  'recommendationPreferences' => ''
]));

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

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

append(json_encode([
  'accountIds' => '',
  'filters' => '',
  'fieldsToExport' => '',
  's3DestinationConfig' => '',
  'fileFormat' => '',
  'includeMemberAccounts' => '',
  'recommendationPreferences' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportAutoScalingGroupRecommendations');
$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=ComputeOptimizerService.ExportAutoScalingGroupRecommendations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": "",
  "fileFormat": "",
  "includeMemberAccounts": "",
  "recommendationPreferences": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportAutoScalingGroupRecommendations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": "",
  "fileFormat": "",
  "includeMemberAccounts": "",
  "recommendationPreferences": ""
}'

import http.client

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

payload = "{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": \"\",\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\",\n  \"recommendationPreferences\": \"\"\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=ComputeOptimizerService.ExportAutoScalingGroupRecommendations"

payload = {
    "accountIds": "",
    "filters": "",
    "fieldsToExport": "",
    "s3DestinationConfig": "",
    "fileFormat": "",
    "includeMemberAccounts": "",
    "recommendationPreferences": ""
}
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=ComputeOptimizerService.ExportAutoScalingGroupRecommendations"

payload <- "{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": \"\",\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\",\n  \"recommendationPreferences\": \"\"\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=ComputeOptimizerService.ExportAutoScalingGroupRecommendations")

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  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": \"\",\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\",\n  \"recommendationPreferences\": \"\"\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  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": \"\",\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\",\n  \"recommendationPreferences\": \"\"\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=ComputeOptimizerService.ExportAutoScalingGroupRecommendations";

    let payload = json!({
        "accountIds": "",
        "filters": "",
        "fieldsToExport": "",
        "s3DestinationConfig": "",
        "fileFormat": "",
        "includeMemberAccounts": "",
        "recommendationPreferences": ""
    });

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

echo '{
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": "",
  "fileFormat": "",
  "includeMemberAccounts": "",
  "recommendationPreferences": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportAutoScalingGroupRecommendations' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "accountIds": "",\n  "filters": "",\n  "fieldsToExport": "",\n  "s3DestinationConfig": "",\n  "fileFormat": "",\n  "includeMemberAccounts": "",\n  "recommendationPreferences": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportAutoScalingGroupRecommendations'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": "",
  "fileFormat": "",
  "includeMemberAccounts": "",
  "recommendationPreferences": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportAutoScalingGroupRecommendations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEBSVolumeRecommendations" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:accountIds ""
                                                                                                                               :filters ""
                                                                                                                               :fieldsToExport ""
                                                                                                                               :s3DestinationConfig {:bucket ""
                                                                                                                                                     :keyPrefix ""}
                                                                                                                               :fileFormat ""
                                                                                                                               :includeMemberAccounts ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEBSVolumeRecommendations"

	payload := strings.NewReader("{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\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: 184

{
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": {
    "bucket": "",
    "keyPrefix": ""
  },
  "fileFormat": "",
  "includeMemberAccounts": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEBSVolumeRecommendations")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEBSVolumeRecommendations"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\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  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEBSVolumeRecommendations")
  .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=ComputeOptimizerService.ExportEBSVolumeRecommendations")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  accountIds: '',
  filters: '',
  fieldsToExport: '',
  s3DestinationConfig: {
    bucket: '',
    keyPrefix: ''
  },
  fileFormat: '',
  includeMemberAccounts: ''
});

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=ComputeOptimizerService.ExportEBSVolumeRecommendations');
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=ComputeOptimizerService.ExportEBSVolumeRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    accountIds: '',
    filters: '',
    fieldsToExport: '',
    s3DestinationConfig: {bucket: '', keyPrefix: ''},
    fileFormat: '',
    includeMemberAccounts: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEBSVolumeRecommendations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"accountIds":"","filters":"","fieldsToExport":"","s3DestinationConfig":{"bucket":"","keyPrefix":""},"fileFormat":"","includeMemberAccounts":""}'
};

try {
  const response = await 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=ComputeOptimizerService.ExportEBSVolumeRecommendations',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "accountIds": "",\n  "filters": "",\n  "fieldsToExport": "",\n  "s3DestinationConfig": {\n    "bucket": "",\n    "keyPrefix": ""\n  },\n  "fileFormat": "",\n  "includeMemberAccounts": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEBSVolumeRecommendations")
  .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({
  accountIds: '',
  filters: '',
  fieldsToExport: '',
  s3DestinationConfig: {bucket: '', keyPrefix: ''},
  fileFormat: '',
  includeMemberAccounts: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEBSVolumeRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    accountIds: '',
    filters: '',
    fieldsToExport: '',
    s3DestinationConfig: {bucket: '', keyPrefix: ''},
    fileFormat: '',
    includeMemberAccounts: ''
  },
  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=ComputeOptimizerService.ExportEBSVolumeRecommendations');

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

req.type('json');
req.send({
  accountIds: '',
  filters: '',
  fieldsToExport: '',
  s3DestinationConfig: {
    bucket: '',
    keyPrefix: ''
  },
  fileFormat: '',
  includeMemberAccounts: ''
});

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=ComputeOptimizerService.ExportEBSVolumeRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    accountIds: '',
    filters: '',
    fieldsToExport: '',
    s3DestinationConfig: {bucket: '', keyPrefix: ''},
    fileFormat: '',
    includeMemberAccounts: ''
  }
};

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=ComputeOptimizerService.ExportEBSVolumeRecommendations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"accountIds":"","filters":"","fieldsToExport":"","s3DestinationConfig":{"bucket":"","keyPrefix":""},"fileFormat":"","includeMemberAccounts":""}'
};

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 = @{ @"accountIds": @"",
                              @"filters": @"",
                              @"fieldsToExport": @"",
                              @"s3DestinationConfig": @{ @"bucket": @"", @"keyPrefix": @"" },
                              @"fileFormat": @"",
                              @"includeMemberAccounts": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEBSVolumeRecommendations"]
                                                       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=ComputeOptimizerService.ExportEBSVolumeRecommendations" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEBSVolumeRecommendations",
  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([
    'accountIds' => '',
    'filters' => '',
    'fieldsToExport' => '',
    's3DestinationConfig' => [
        'bucket' => '',
        'keyPrefix' => ''
    ],
    'fileFormat' => '',
    'includeMemberAccounts' => ''
  ]),
  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=ComputeOptimizerService.ExportEBSVolumeRecommendations', [
  'body' => '{
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": {
    "bucket": "",
    "keyPrefix": ""
  },
  "fileFormat": "",
  "includeMemberAccounts": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'accountIds' => '',
  'filters' => '',
  'fieldsToExport' => '',
  's3DestinationConfig' => [
    'bucket' => '',
    'keyPrefix' => ''
  ],
  'fileFormat' => '',
  'includeMemberAccounts' => ''
]));

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

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

append(json_encode([
  'accountIds' => '',
  'filters' => '',
  'fieldsToExport' => '',
  's3DestinationConfig' => [
    'bucket' => '',
    'keyPrefix' => ''
  ],
  'fileFormat' => '',
  'includeMemberAccounts' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEBSVolumeRecommendations');
$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=ComputeOptimizerService.ExportEBSVolumeRecommendations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": {
    "bucket": "",
    "keyPrefix": ""
  },
  "fileFormat": "",
  "includeMemberAccounts": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEBSVolumeRecommendations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": {
    "bucket": "",
    "keyPrefix": ""
  },
  "fileFormat": "",
  "includeMemberAccounts": ""
}'

import http.client

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

payload = "{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\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=ComputeOptimizerService.ExportEBSVolumeRecommendations"

payload = {
    "accountIds": "",
    "filters": "",
    "fieldsToExport": "",
    "s3DestinationConfig": {
        "bucket": "",
        "keyPrefix": ""
    },
    "fileFormat": "",
    "includeMemberAccounts": ""
}
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=ComputeOptimizerService.ExportEBSVolumeRecommendations"

payload <- "{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\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=ComputeOptimizerService.ExportEBSVolumeRecommendations")

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  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\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  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\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=ComputeOptimizerService.ExportEBSVolumeRecommendations";

    let payload = json!({
        "accountIds": "",
        "filters": "",
        "fieldsToExport": "",
        "s3DestinationConfig": json!({
            "bucket": "",
            "keyPrefix": ""
        }),
        "fileFormat": "",
        "includeMemberAccounts": ""
    });

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

echo '{
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": {
    "bucket": "",
    "keyPrefix": ""
  },
  "fileFormat": "",
  "includeMemberAccounts": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEBSVolumeRecommendations' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "accountIds": "",\n  "filters": "",\n  "fieldsToExport": "",\n  "s3DestinationConfig": {\n    "bucket": "",\n    "keyPrefix": ""\n  },\n  "fileFormat": "",\n  "includeMemberAccounts": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEBSVolumeRecommendations'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": [
    "bucket": "",
    "keyPrefix": ""
  ],
  "fileFormat": "",
  "includeMemberAccounts": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEBSVolumeRecommendations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": \"\",\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\",\n  \"recommendationPreferences\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEC2InstanceRecommendations" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:accountIds ""
                                                                                                                                 :filters ""
                                                                                                                                 :fieldsToExport ""
                                                                                                                                 :s3DestinationConfig ""
                                                                                                                                 :fileFormat ""
                                                                                                                                 :includeMemberAccounts ""
                                                                                                                                 :recommendationPreferences ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEC2InstanceRecommendations"

	payload := strings.NewReader("{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": \"\",\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\",\n  \"recommendationPreferences\": \"\"\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: 178

{
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": "",
  "fileFormat": "",
  "includeMemberAccounts": "",
  "recommendationPreferences": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEC2InstanceRecommendations")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": \"\",\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\",\n  \"recommendationPreferences\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

const data = JSON.stringify({
  accountIds: '',
  filters: '',
  fieldsToExport: '',
  s3DestinationConfig: '',
  fileFormat: '',
  includeMemberAccounts: '',
  recommendationPreferences: ''
});

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=ComputeOptimizerService.ExportEC2InstanceRecommendations');
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=ComputeOptimizerService.ExportEC2InstanceRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    accountIds: '',
    filters: '',
    fieldsToExport: '',
    s3DestinationConfig: '',
    fileFormat: '',
    includeMemberAccounts: '',
    recommendationPreferences: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEC2InstanceRecommendations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"accountIds":"","filters":"","fieldsToExport":"","s3DestinationConfig":"","fileFormat":"","includeMemberAccounts":"","recommendationPreferences":""}'
};

try {
  const response = await 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=ComputeOptimizerService.ExportEC2InstanceRecommendations',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "accountIds": "",\n  "filters": "",\n  "fieldsToExport": "",\n  "s3DestinationConfig": "",\n  "fileFormat": "",\n  "includeMemberAccounts": "",\n  "recommendationPreferences": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": \"\",\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\",\n  \"recommendationPreferences\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEC2InstanceRecommendations")
  .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({
  accountIds: '',
  filters: '',
  fieldsToExport: '',
  s3DestinationConfig: '',
  fileFormat: '',
  includeMemberAccounts: '',
  recommendationPreferences: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEC2InstanceRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    accountIds: '',
    filters: '',
    fieldsToExport: '',
    s3DestinationConfig: '',
    fileFormat: '',
    includeMemberAccounts: '',
    recommendationPreferences: ''
  },
  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=ComputeOptimizerService.ExportEC2InstanceRecommendations');

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

req.type('json');
req.send({
  accountIds: '',
  filters: '',
  fieldsToExport: '',
  s3DestinationConfig: '',
  fileFormat: '',
  includeMemberAccounts: '',
  recommendationPreferences: ''
});

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=ComputeOptimizerService.ExportEC2InstanceRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    accountIds: '',
    filters: '',
    fieldsToExport: '',
    s3DestinationConfig: '',
    fileFormat: '',
    includeMemberAccounts: '',
    recommendationPreferences: ''
  }
};

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=ComputeOptimizerService.ExportEC2InstanceRecommendations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"accountIds":"","filters":"","fieldsToExport":"","s3DestinationConfig":"","fileFormat":"","includeMemberAccounts":"","recommendationPreferences":""}'
};

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 = @{ @"accountIds": @"",
                              @"filters": @"",
                              @"fieldsToExport": @"",
                              @"s3DestinationConfig": @"",
                              @"fileFormat": @"",
                              @"includeMemberAccounts": @"",
                              @"recommendationPreferences": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEC2InstanceRecommendations",
  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([
    'accountIds' => '',
    'filters' => '',
    'fieldsToExport' => '',
    's3DestinationConfig' => '',
    'fileFormat' => '',
    'includeMemberAccounts' => '',
    'recommendationPreferences' => ''
  ]),
  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=ComputeOptimizerService.ExportEC2InstanceRecommendations', [
  'body' => '{
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": "",
  "fileFormat": "",
  "includeMemberAccounts": "",
  "recommendationPreferences": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'accountIds' => '',
  'filters' => '',
  'fieldsToExport' => '',
  's3DestinationConfig' => '',
  'fileFormat' => '',
  'includeMemberAccounts' => '',
  'recommendationPreferences' => ''
]));

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

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

append(json_encode([
  'accountIds' => '',
  'filters' => '',
  'fieldsToExport' => '',
  's3DestinationConfig' => '',
  'fileFormat' => '',
  'includeMemberAccounts' => '',
  'recommendationPreferences' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEC2InstanceRecommendations');
$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=ComputeOptimizerService.ExportEC2InstanceRecommendations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": "",
  "fileFormat": "",
  "includeMemberAccounts": "",
  "recommendationPreferences": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEC2InstanceRecommendations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": "",
  "fileFormat": "",
  "includeMemberAccounts": "",
  "recommendationPreferences": ""
}'

import http.client

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

payload = "{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": \"\",\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\",\n  \"recommendationPreferences\": \"\"\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=ComputeOptimizerService.ExportEC2InstanceRecommendations"

payload = {
    "accountIds": "",
    "filters": "",
    "fieldsToExport": "",
    "s3DestinationConfig": "",
    "fileFormat": "",
    "includeMemberAccounts": "",
    "recommendationPreferences": ""
}
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=ComputeOptimizerService.ExportEC2InstanceRecommendations"

payload <- "{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": \"\",\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\",\n  \"recommendationPreferences\": \"\"\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=ComputeOptimizerService.ExportEC2InstanceRecommendations")

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  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": \"\",\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\",\n  \"recommendationPreferences\": \"\"\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  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": \"\",\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\",\n  \"recommendationPreferences\": \"\"\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=ComputeOptimizerService.ExportEC2InstanceRecommendations";

    let payload = json!({
        "accountIds": "",
        "filters": "",
        "fieldsToExport": "",
        "s3DestinationConfig": "",
        "fileFormat": "",
        "includeMemberAccounts": "",
        "recommendationPreferences": ""
    });

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

echo '{
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": "",
  "fileFormat": "",
  "includeMemberAccounts": "",
  "recommendationPreferences": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEC2InstanceRecommendations' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "accountIds": "",\n  "filters": "",\n  "fieldsToExport": "",\n  "s3DestinationConfig": "",\n  "fileFormat": "",\n  "includeMemberAccounts": "",\n  "recommendationPreferences": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEC2InstanceRecommendations'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": "",
  "fileFormat": "",
  "includeMemberAccounts": "",
  "recommendationPreferences": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportEC2InstanceRecommendations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportECSServiceRecommendations" {:headers {:x-amz-target ""}
                                                                                                                  :content-type :json
                                                                                                                  :form-params {:accountIds ""
                                                                                                                                :filters ""
                                                                                                                                :fieldsToExport ""
                                                                                                                                :s3DestinationConfig {:bucket ""
                                                                                                                                                      :keyPrefix ""}
                                                                                                                                :fileFormat ""
                                                                                                                                :includeMemberAccounts ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportECSServiceRecommendations"

	payload := strings.NewReader("{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\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: 184

{
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": {
    "bucket": "",
    "keyPrefix": ""
  },
  "fileFormat": "",
  "includeMemberAccounts": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportECSServiceRecommendations")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportECSServiceRecommendations"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\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  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportECSServiceRecommendations")
  .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=ComputeOptimizerService.ExportECSServiceRecommendations")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  accountIds: '',
  filters: '',
  fieldsToExport: '',
  s3DestinationConfig: {
    bucket: '',
    keyPrefix: ''
  },
  fileFormat: '',
  includeMemberAccounts: ''
});

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=ComputeOptimizerService.ExportECSServiceRecommendations');
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=ComputeOptimizerService.ExportECSServiceRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    accountIds: '',
    filters: '',
    fieldsToExport: '',
    s3DestinationConfig: {bucket: '', keyPrefix: ''},
    fileFormat: '',
    includeMemberAccounts: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportECSServiceRecommendations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"accountIds":"","filters":"","fieldsToExport":"","s3DestinationConfig":{"bucket":"","keyPrefix":""},"fileFormat":"","includeMemberAccounts":""}'
};

try {
  const response = await 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=ComputeOptimizerService.ExportECSServiceRecommendations',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "accountIds": "",\n  "filters": "",\n  "fieldsToExport": "",\n  "s3DestinationConfig": {\n    "bucket": "",\n    "keyPrefix": ""\n  },\n  "fileFormat": "",\n  "includeMemberAccounts": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportECSServiceRecommendations")
  .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({
  accountIds: '',
  filters: '',
  fieldsToExport: '',
  s3DestinationConfig: {bucket: '', keyPrefix: ''},
  fileFormat: '',
  includeMemberAccounts: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportECSServiceRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    accountIds: '',
    filters: '',
    fieldsToExport: '',
    s3DestinationConfig: {bucket: '', keyPrefix: ''},
    fileFormat: '',
    includeMemberAccounts: ''
  },
  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=ComputeOptimizerService.ExportECSServiceRecommendations');

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

req.type('json');
req.send({
  accountIds: '',
  filters: '',
  fieldsToExport: '',
  s3DestinationConfig: {
    bucket: '',
    keyPrefix: ''
  },
  fileFormat: '',
  includeMemberAccounts: ''
});

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=ComputeOptimizerService.ExportECSServiceRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    accountIds: '',
    filters: '',
    fieldsToExport: '',
    s3DestinationConfig: {bucket: '', keyPrefix: ''},
    fileFormat: '',
    includeMemberAccounts: ''
  }
};

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=ComputeOptimizerService.ExportECSServiceRecommendations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"accountIds":"","filters":"","fieldsToExport":"","s3DestinationConfig":{"bucket":"","keyPrefix":""},"fileFormat":"","includeMemberAccounts":""}'
};

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 = @{ @"accountIds": @"",
                              @"filters": @"",
                              @"fieldsToExport": @"",
                              @"s3DestinationConfig": @{ @"bucket": @"", @"keyPrefix": @"" },
                              @"fileFormat": @"",
                              @"includeMemberAccounts": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportECSServiceRecommendations"]
                                                       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=ComputeOptimizerService.ExportECSServiceRecommendations" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportECSServiceRecommendations",
  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([
    'accountIds' => '',
    'filters' => '',
    'fieldsToExport' => '',
    's3DestinationConfig' => [
        'bucket' => '',
        'keyPrefix' => ''
    ],
    'fileFormat' => '',
    'includeMemberAccounts' => ''
  ]),
  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=ComputeOptimizerService.ExportECSServiceRecommendations', [
  'body' => '{
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": {
    "bucket": "",
    "keyPrefix": ""
  },
  "fileFormat": "",
  "includeMemberAccounts": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'accountIds' => '',
  'filters' => '',
  'fieldsToExport' => '',
  's3DestinationConfig' => [
    'bucket' => '',
    'keyPrefix' => ''
  ],
  'fileFormat' => '',
  'includeMemberAccounts' => ''
]));

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

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

append(json_encode([
  'accountIds' => '',
  'filters' => '',
  'fieldsToExport' => '',
  's3DestinationConfig' => [
    'bucket' => '',
    'keyPrefix' => ''
  ],
  'fileFormat' => '',
  'includeMemberAccounts' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportECSServiceRecommendations');
$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=ComputeOptimizerService.ExportECSServiceRecommendations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": {
    "bucket": "",
    "keyPrefix": ""
  },
  "fileFormat": "",
  "includeMemberAccounts": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportECSServiceRecommendations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": {
    "bucket": "",
    "keyPrefix": ""
  },
  "fileFormat": "",
  "includeMemberAccounts": ""
}'

import http.client

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

payload = "{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\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=ComputeOptimizerService.ExportECSServiceRecommendations"

payload = {
    "accountIds": "",
    "filters": "",
    "fieldsToExport": "",
    "s3DestinationConfig": {
        "bucket": "",
        "keyPrefix": ""
    },
    "fileFormat": "",
    "includeMemberAccounts": ""
}
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=ComputeOptimizerService.ExportECSServiceRecommendations"

payload <- "{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\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=ComputeOptimizerService.ExportECSServiceRecommendations")

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  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\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  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\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=ComputeOptimizerService.ExportECSServiceRecommendations";

    let payload = json!({
        "accountIds": "",
        "filters": "",
        "fieldsToExport": "",
        "s3DestinationConfig": json!({
            "bucket": "",
            "keyPrefix": ""
        }),
        "fileFormat": "",
        "includeMemberAccounts": ""
    });

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

echo '{
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": {
    "bucket": "",
    "keyPrefix": ""
  },
  "fileFormat": "",
  "includeMemberAccounts": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportECSServiceRecommendations' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "accountIds": "",\n  "filters": "",\n  "fieldsToExport": "",\n  "s3DestinationConfig": {\n    "bucket": "",\n    "keyPrefix": ""\n  },\n  "fileFormat": "",\n  "includeMemberAccounts": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportECSServiceRecommendations'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": [
    "bucket": "",
    "keyPrefix": ""
  ],
  "fileFormat": "",
  "includeMemberAccounts": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportECSServiceRecommendations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportLambdaFunctionRecommendations" {:headers {:x-amz-target ""}
                                                                                                                      :content-type :json
                                                                                                                      :form-params {:accountIds ""
                                                                                                                                    :filters ""
                                                                                                                                    :fieldsToExport ""
                                                                                                                                    :s3DestinationConfig {:bucket ""
                                                                                                                                                          :keyPrefix ""}
                                                                                                                                    :fileFormat ""
                                                                                                                                    :includeMemberAccounts ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportLambdaFunctionRecommendations"

	payload := strings.NewReader("{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\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: 184

{
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": {
    "bucket": "",
    "keyPrefix": ""
  },
  "fileFormat": "",
  "includeMemberAccounts": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportLambdaFunctionRecommendations")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportLambdaFunctionRecommendations"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\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  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportLambdaFunctionRecommendations")
  .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=ComputeOptimizerService.ExportLambdaFunctionRecommendations")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  accountIds: '',
  filters: '',
  fieldsToExport: '',
  s3DestinationConfig: {
    bucket: '',
    keyPrefix: ''
  },
  fileFormat: '',
  includeMemberAccounts: ''
});

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=ComputeOptimizerService.ExportLambdaFunctionRecommendations');
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=ComputeOptimizerService.ExportLambdaFunctionRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    accountIds: '',
    filters: '',
    fieldsToExport: '',
    s3DestinationConfig: {bucket: '', keyPrefix: ''},
    fileFormat: '',
    includeMemberAccounts: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportLambdaFunctionRecommendations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"accountIds":"","filters":"","fieldsToExport":"","s3DestinationConfig":{"bucket":"","keyPrefix":""},"fileFormat":"","includeMemberAccounts":""}'
};

try {
  const response = await 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=ComputeOptimizerService.ExportLambdaFunctionRecommendations',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "accountIds": "",\n  "filters": "",\n  "fieldsToExport": "",\n  "s3DestinationConfig": {\n    "bucket": "",\n    "keyPrefix": ""\n  },\n  "fileFormat": "",\n  "includeMemberAccounts": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportLambdaFunctionRecommendations")
  .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({
  accountIds: '',
  filters: '',
  fieldsToExport: '',
  s3DestinationConfig: {bucket: '', keyPrefix: ''},
  fileFormat: '',
  includeMemberAccounts: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportLambdaFunctionRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    accountIds: '',
    filters: '',
    fieldsToExport: '',
    s3DestinationConfig: {bucket: '', keyPrefix: ''},
    fileFormat: '',
    includeMemberAccounts: ''
  },
  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=ComputeOptimizerService.ExportLambdaFunctionRecommendations');

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

req.type('json');
req.send({
  accountIds: '',
  filters: '',
  fieldsToExport: '',
  s3DestinationConfig: {
    bucket: '',
    keyPrefix: ''
  },
  fileFormat: '',
  includeMemberAccounts: ''
});

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=ComputeOptimizerService.ExportLambdaFunctionRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    accountIds: '',
    filters: '',
    fieldsToExport: '',
    s3DestinationConfig: {bucket: '', keyPrefix: ''},
    fileFormat: '',
    includeMemberAccounts: ''
  }
};

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=ComputeOptimizerService.ExportLambdaFunctionRecommendations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"accountIds":"","filters":"","fieldsToExport":"","s3DestinationConfig":{"bucket":"","keyPrefix":""},"fileFormat":"","includeMemberAccounts":""}'
};

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 = @{ @"accountIds": @"",
                              @"filters": @"",
                              @"fieldsToExport": @"",
                              @"s3DestinationConfig": @{ @"bucket": @"", @"keyPrefix": @"" },
                              @"fileFormat": @"",
                              @"includeMemberAccounts": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportLambdaFunctionRecommendations"]
                                                       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=ComputeOptimizerService.ExportLambdaFunctionRecommendations" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportLambdaFunctionRecommendations",
  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([
    'accountIds' => '',
    'filters' => '',
    'fieldsToExport' => '',
    's3DestinationConfig' => [
        'bucket' => '',
        'keyPrefix' => ''
    ],
    'fileFormat' => '',
    'includeMemberAccounts' => ''
  ]),
  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=ComputeOptimizerService.ExportLambdaFunctionRecommendations', [
  'body' => '{
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": {
    "bucket": "",
    "keyPrefix": ""
  },
  "fileFormat": "",
  "includeMemberAccounts": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'accountIds' => '',
  'filters' => '',
  'fieldsToExport' => '',
  's3DestinationConfig' => [
    'bucket' => '',
    'keyPrefix' => ''
  ],
  'fileFormat' => '',
  'includeMemberAccounts' => ''
]));

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

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

append(json_encode([
  'accountIds' => '',
  'filters' => '',
  'fieldsToExport' => '',
  's3DestinationConfig' => [
    'bucket' => '',
    'keyPrefix' => ''
  ],
  'fileFormat' => '',
  'includeMemberAccounts' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportLambdaFunctionRecommendations');
$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=ComputeOptimizerService.ExportLambdaFunctionRecommendations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": {
    "bucket": "",
    "keyPrefix": ""
  },
  "fileFormat": "",
  "includeMemberAccounts": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportLambdaFunctionRecommendations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": {
    "bucket": "",
    "keyPrefix": ""
  },
  "fileFormat": "",
  "includeMemberAccounts": ""
}'

import http.client

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

payload = "{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\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=ComputeOptimizerService.ExportLambdaFunctionRecommendations"

payload = {
    "accountIds": "",
    "filters": "",
    "fieldsToExport": "",
    "s3DestinationConfig": {
        "bucket": "",
        "keyPrefix": ""
    },
    "fileFormat": "",
    "includeMemberAccounts": ""
}
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=ComputeOptimizerService.ExportLambdaFunctionRecommendations"

payload <- "{\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\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=ComputeOptimizerService.ExportLambdaFunctionRecommendations")

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  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\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  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"fieldsToExport\": \"\",\n  \"s3DestinationConfig\": {\n    \"bucket\": \"\",\n    \"keyPrefix\": \"\"\n  },\n  \"fileFormat\": \"\",\n  \"includeMemberAccounts\": \"\"\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=ComputeOptimizerService.ExportLambdaFunctionRecommendations";

    let payload = json!({
        "accountIds": "",
        "filters": "",
        "fieldsToExport": "",
        "s3DestinationConfig": json!({
            "bucket": "",
            "keyPrefix": ""
        }),
        "fileFormat": "",
        "includeMemberAccounts": ""
    });

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

echo '{
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": {
    "bucket": "",
    "keyPrefix": ""
  },
  "fileFormat": "",
  "includeMemberAccounts": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportLambdaFunctionRecommendations' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "accountIds": "",\n  "filters": "",\n  "fieldsToExport": "",\n  "s3DestinationConfig": {\n    "bucket": "",\n    "keyPrefix": ""\n  },\n  "fileFormat": "",\n  "includeMemberAccounts": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportLambdaFunctionRecommendations'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "accountIds": "",
  "filters": "",
  "fieldsToExport": "",
  "s3DestinationConfig": [
    "bucket": "",
    "keyPrefix": ""
  ],
  "fileFormat": "",
  "includeMemberAccounts": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.ExportLambdaFunctionRecommendations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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  \"accountIds\": \"\",\n  \"autoScalingGroupArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"recommendationPreferences\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetAutoScalingGroupRecommendations" {:headers {:x-amz-target ""}
                                                                                                                     :content-type :json
                                                                                                                     :form-params {:accountIds ""
                                                                                                                                   :autoScalingGroupArns ""
                                                                                                                                   :nextToken ""
                                                                                                                                   :maxResults ""
                                                                                                                                   :filters ""
                                                                                                                                   :recommendationPreferences ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetAutoScalingGroupRecommendations"

	payload := strings.NewReader("{\n  \"accountIds\": \"\",\n  \"autoScalingGroupArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"recommendationPreferences\": \"\"\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: 143

{
  "accountIds": "",
  "autoScalingGroupArns": "",
  "nextToken": "",
  "maxResults": "",
  "filters": "",
  "recommendationPreferences": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetAutoScalingGroupRecommendations")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"accountIds\": \"\",\n  \"autoScalingGroupArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"recommendationPreferences\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

const data = JSON.stringify({
  accountIds: '',
  autoScalingGroupArns: '',
  nextToken: '',
  maxResults: '',
  filters: '',
  recommendationPreferences: ''
});

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=ComputeOptimizerService.GetAutoScalingGroupRecommendations');
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=ComputeOptimizerService.GetAutoScalingGroupRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    accountIds: '',
    autoScalingGroupArns: '',
    nextToken: '',
    maxResults: '',
    filters: '',
    recommendationPreferences: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetAutoScalingGroupRecommendations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"accountIds":"","autoScalingGroupArns":"","nextToken":"","maxResults":"","filters":"","recommendationPreferences":""}'
};

try {
  const response = await 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=ComputeOptimizerService.GetAutoScalingGroupRecommendations',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "accountIds": "",\n  "autoScalingGroupArns": "",\n  "nextToken": "",\n  "maxResults": "",\n  "filters": "",\n  "recommendationPreferences": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"accountIds\": \"\",\n  \"autoScalingGroupArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"recommendationPreferences\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetAutoScalingGroupRecommendations")
  .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({
  accountIds: '',
  autoScalingGroupArns: '',
  nextToken: '',
  maxResults: '',
  filters: '',
  recommendationPreferences: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetAutoScalingGroupRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    accountIds: '',
    autoScalingGroupArns: '',
    nextToken: '',
    maxResults: '',
    filters: '',
    recommendationPreferences: ''
  },
  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=ComputeOptimizerService.GetAutoScalingGroupRecommendations');

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

req.type('json');
req.send({
  accountIds: '',
  autoScalingGroupArns: '',
  nextToken: '',
  maxResults: '',
  filters: '',
  recommendationPreferences: ''
});

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=ComputeOptimizerService.GetAutoScalingGroupRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    accountIds: '',
    autoScalingGroupArns: '',
    nextToken: '',
    maxResults: '',
    filters: '',
    recommendationPreferences: ''
  }
};

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=ComputeOptimizerService.GetAutoScalingGroupRecommendations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"accountIds":"","autoScalingGroupArns":"","nextToken":"","maxResults":"","filters":"","recommendationPreferences":""}'
};

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 = @{ @"accountIds": @"",
                              @"autoScalingGroupArns": @"",
                              @"nextToken": @"",
                              @"maxResults": @"",
                              @"filters": @"",
                              @"recommendationPreferences": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetAutoScalingGroupRecommendations",
  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([
    'accountIds' => '',
    'autoScalingGroupArns' => '',
    'nextToken' => '',
    'maxResults' => '',
    'filters' => '',
    'recommendationPreferences' => ''
  ]),
  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=ComputeOptimizerService.GetAutoScalingGroupRecommendations', [
  'body' => '{
  "accountIds": "",
  "autoScalingGroupArns": "",
  "nextToken": "",
  "maxResults": "",
  "filters": "",
  "recommendationPreferences": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'accountIds' => '',
  'autoScalingGroupArns' => '',
  'nextToken' => '',
  'maxResults' => '',
  'filters' => '',
  'recommendationPreferences' => ''
]));

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

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

append(json_encode([
  'accountIds' => '',
  'autoScalingGroupArns' => '',
  'nextToken' => '',
  'maxResults' => '',
  'filters' => '',
  'recommendationPreferences' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetAutoScalingGroupRecommendations');
$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=ComputeOptimizerService.GetAutoScalingGroupRecommendations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "accountIds": "",
  "autoScalingGroupArns": "",
  "nextToken": "",
  "maxResults": "",
  "filters": "",
  "recommendationPreferences": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetAutoScalingGroupRecommendations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "accountIds": "",
  "autoScalingGroupArns": "",
  "nextToken": "",
  "maxResults": "",
  "filters": "",
  "recommendationPreferences": ""
}'

import http.client

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

payload = "{\n  \"accountIds\": \"\",\n  \"autoScalingGroupArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"recommendationPreferences\": \"\"\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=ComputeOptimizerService.GetAutoScalingGroupRecommendations"

payload = {
    "accountIds": "",
    "autoScalingGroupArns": "",
    "nextToken": "",
    "maxResults": "",
    "filters": "",
    "recommendationPreferences": ""
}
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=ComputeOptimizerService.GetAutoScalingGroupRecommendations"

payload <- "{\n  \"accountIds\": \"\",\n  \"autoScalingGroupArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"recommendationPreferences\": \"\"\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=ComputeOptimizerService.GetAutoScalingGroupRecommendations")

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  \"accountIds\": \"\",\n  \"autoScalingGroupArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"recommendationPreferences\": \"\"\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  \"accountIds\": \"\",\n  \"autoScalingGroupArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"recommendationPreferences\": \"\"\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=ComputeOptimizerService.GetAutoScalingGroupRecommendations";

    let payload = json!({
        "accountIds": "",
        "autoScalingGroupArns": "",
        "nextToken": "",
        "maxResults": "",
        "filters": "",
        "recommendationPreferences": ""
    });

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

echo '{
  "accountIds": "",
  "autoScalingGroupArns": "",
  "nextToken": "",
  "maxResults": "",
  "filters": "",
  "recommendationPreferences": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetAutoScalingGroupRecommendations' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "accountIds": "",\n  "autoScalingGroupArns": "",\n  "nextToken": "",\n  "maxResults": "",\n  "filters": "",\n  "recommendationPreferences": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetAutoScalingGroupRecommendations'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "accountIds": "",
  "autoScalingGroupArns": "",
  "nextToken": "",
  "maxResults": "",
  "filters": "",
  "recommendationPreferences": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetAutoScalingGroupRecommendations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"volumeArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"accountIds\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEBSVolumeRecommendations" {:headers {:x-amz-target ""}
                                                                                                              :content-type :json
                                                                                                              :form-params {:volumeArns ""
                                                                                                                            :nextToken ""
                                                                                                                            :maxResults ""
                                                                                                                            :filters ""
                                                                                                                            :accountIds ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEBSVolumeRecommendations"

	payload := strings.NewReader("{\n  \"volumeArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"accountIds\": \"\"\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: 98

{
  "volumeArns": "",
  "nextToken": "",
  "maxResults": "",
  "filters": "",
  "accountIds": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"volumeArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"accountIds\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEBSVolumeRecommendations")
  .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=ComputeOptimizerService.GetEBSVolumeRecommendations")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"volumeArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"accountIds\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  volumeArns: '',
  nextToken: '',
  maxResults: '',
  filters: '',
  accountIds: ''
});

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=ComputeOptimizerService.GetEBSVolumeRecommendations');
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=ComputeOptimizerService.GetEBSVolumeRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {volumeArns: '', nextToken: '', maxResults: '', filters: '', accountIds: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEBSVolumeRecommendations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"volumeArns":"","nextToken":"","maxResults":"","filters":"","accountIds":""}'
};

try {
  const response = await 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=ComputeOptimizerService.GetEBSVolumeRecommendations',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "volumeArns": "",\n  "nextToken": "",\n  "maxResults": "",\n  "filters": "",\n  "accountIds": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"volumeArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"accountIds\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEBSVolumeRecommendations")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

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

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

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

req.write(JSON.stringify({volumeArns: '', nextToken: '', maxResults: '', filters: '', accountIds: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEBSVolumeRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {volumeArns: '', nextToken: '', maxResults: '', filters: '', accountIds: ''},
  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=ComputeOptimizerService.GetEBSVolumeRecommendations');

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

req.type('json');
req.send({
  volumeArns: '',
  nextToken: '',
  maxResults: '',
  filters: '',
  accountIds: ''
});

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=ComputeOptimizerService.GetEBSVolumeRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {volumeArns: '', nextToken: '', maxResults: '', filters: '', accountIds: ''}
};

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=ComputeOptimizerService.GetEBSVolumeRecommendations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"volumeArns":"","nextToken":"","maxResults":"","filters":"","accountIds":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"volumeArns": @"",
                              @"nextToken": @"",
                              @"maxResults": @"",
                              @"filters": @"",
                              @"accountIds": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEBSVolumeRecommendations",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'volumeArns' => '',
    'nextToken' => '',
    'maxResults' => '',
    'filters' => '',
    'accountIds' => ''
  ]),
  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=ComputeOptimizerService.GetEBSVolumeRecommendations', [
  'body' => '{
  "volumeArns": "",
  "nextToken": "",
  "maxResults": "",
  "filters": "",
  "accountIds": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'volumeArns' => '',
  'nextToken' => '',
  'maxResults' => '',
  'filters' => '',
  'accountIds' => ''
]));

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

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

append(json_encode([
  'volumeArns' => '',
  'nextToken' => '',
  'maxResults' => '',
  'filters' => '',
  'accountIds' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEBSVolumeRecommendations');
$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=ComputeOptimizerService.GetEBSVolumeRecommendations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "volumeArns": "",
  "nextToken": "",
  "maxResults": "",
  "filters": "",
  "accountIds": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEBSVolumeRecommendations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "volumeArns": "",
  "nextToken": "",
  "maxResults": "",
  "filters": "",
  "accountIds": ""
}'

import http.client

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

payload = "{\n  \"volumeArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"accountIds\": \"\"\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=ComputeOptimizerService.GetEBSVolumeRecommendations"

payload = {
    "volumeArns": "",
    "nextToken": "",
    "maxResults": "",
    "filters": "",
    "accountIds": ""
}
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=ComputeOptimizerService.GetEBSVolumeRecommendations"

payload <- "{\n  \"volumeArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"accountIds\": \"\"\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=ComputeOptimizerService.GetEBSVolumeRecommendations")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"volumeArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"accountIds\": \"\"\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=ComputeOptimizerService.GetEBSVolumeRecommendations";

    let payload = json!({
        "volumeArns": "",
        "nextToken": "",
        "maxResults": "",
        "filters": "",
        "accountIds": ""
    });

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

echo '{
  "volumeArns": "",
  "nextToken": "",
  "maxResults": "",
  "filters": "",
  "accountIds": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEBSVolumeRecommendations' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "volumeArns": "",\n  "nextToken": "",\n  "maxResults": "",\n  "filters": "",\n  "accountIds": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEBSVolumeRecommendations'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "volumeArns": "",
  "nextToken": "",
  "maxResults": "",
  "filters": "",
  "accountIds": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEBSVolumeRecommendations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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  \"instanceArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"accountIds\": \"\",\n  \"recommendationPreferences\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEC2InstanceRecommendations" {:headers {:x-amz-target ""}
                                                                                                                :content-type :json
                                                                                                                :form-params {:instanceArns ""
                                                                                                                              :nextToken ""
                                                                                                                              :maxResults ""
                                                                                                                              :filters ""
                                                                                                                              :accountIds ""
                                                                                                                              :recommendationPreferences ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEC2InstanceRecommendations"

	payload := strings.NewReader("{\n  \"instanceArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"accountIds\": \"\",\n  \"recommendationPreferences\": \"\"\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

{
  "instanceArns": "",
  "nextToken": "",
  "maxResults": "",
  "filters": "",
  "accountIds": "",
  "recommendationPreferences": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEC2InstanceRecommendations")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"instanceArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"accountIds\": \"\",\n  \"recommendationPreferences\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

const data = JSON.stringify({
  instanceArns: '',
  nextToken: '',
  maxResults: '',
  filters: '',
  accountIds: '',
  recommendationPreferences: ''
});

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=ComputeOptimizerService.GetEC2InstanceRecommendations');
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=ComputeOptimizerService.GetEC2InstanceRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    instanceArns: '',
    nextToken: '',
    maxResults: '',
    filters: '',
    accountIds: '',
    recommendationPreferences: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEC2InstanceRecommendations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"instanceArns":"","nextToken":"","maxResults":"","filters":"","accountIds":"","recommendationPreferences":""}'
};

try {
  const response = await 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=ComputeOptimizerService.GetEC2InstanceRecommendations',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "instanceArns": "",\n  "nextToken": "",\n  "maxResults": "",\n  "filters": "",\n  "accountIds": "",\n  "recommendationPreferences": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"instanceArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"accountIds\": \"\",\n  \"recommendationPreferences\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEC2InstanceRecommendations")
  .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({
  instanceArns: '',
  nextToken: '',
  maxResults: '',
  filters: '',
  accountIds: '',
  recommendationPreferences: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEC2InstanceRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    instanceArns: '',
    nextToken: '',
    maxResults: '',
    filters: '',
    accountIds: '',
    recommendationPreferences: ''
  },
  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=ComputeOptimizerService.GetEC2InstanceRecommendations');

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

req.type('json');
req.send({
  instanceArns: '',
  nextToken: '',
  maxResults: '',
  filters: '',
  accountIds: '',
  recommendationPreferences: ''
});

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=ComputeOptimizerService.GetEC2InstanceRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    instanceArns: '',
    nextToken: '',
    maxResults: '',
    filters: '',
    accountIds: '',
    recommendationPreferences: ''
  }
};

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=ComputeOptimizerService.GetEC2InstanceRecommendations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"instanceArns":"","nextToken":"","maxResults":"","filters":"","accountIds":"","recommendationPreferences":""}'
};

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 = @{ @"instanceArns": @"",
                              @"nextToken": @"",
                              @"maxResults": @"",
                              @"filters": @"",
                              @"accountIds": @"",
                              @"recommendationPreferences": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEC2InstanceRecommendations",
  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([
    'instanceArns' => '',
    'nextToken' => '',
    'maxResults' => '',
    'filters' => '',
    'accountIds' => '',
    'recommendationPreferences' => ''
  ]),
  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=ComputeOptimizerService.GetEC2InstanceRecommendations', [
  'body' => '{
  "instanceArns": "",
  "nextToken": "",
  "maxResults": "",
  "filters": "",
  "accountIds": "",
  "recommendationPreferences": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'instanceArns' => '',
  'nextToken' => '',
  'maxResults' => '',
  'filters' => '',
  'accountIds' => '',
  'recommendationPreferences' => ''
]));

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

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

append(json_encode([
  'instanceArns' => '',
  'nextToken' => '',
  'maxResults' => '',
  'filters' => '',
  'accountIds' => '',
  'recommendationPreferences' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEC2InstanceRecommendations');
$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=ComputeOptimizerService.GetEC2InstanceRecommendations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "instanceArns": "",
  "nextToken": "",
  "maxResults": "",
  "filters": "",
  "accountIds": "",
  "recommendationPreferences": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEC2InstanceRecommendations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "instanceArns": "",
  "nextToken": "",
  "maxResults": "",
  "filters": "",
  "accountIds": "",
  "recommendationPreferences": ""
}'

import http.client

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

payload = "{\n  \"instanceArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"accountIds\": \"\",\n  \"recommendationPreferences\": \"\"\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=ComputeOptimizerService.GetEC2InstanceRecommendations"

payload = {
    "instanceArns": "",
    "nextToken": "",
    "maxResults": "",
    "filters": "",
    "accountIds": "",
    "recommendationPreferences": ""
}
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=ComputeOptimizerService.GetEC2InstanceRecommendations"

payload <- "{\n  \"instanceArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"accountIds\": \"\",\n  \"recommendationPreferences\": \"\"\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=ComputeOptimizerService.GetEC2InstanceRecommendations")

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  \"instanceArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"accountIds\": \"\",\n  \"recommendationPreferences\": \"\"\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  \"instanceArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"accountIds\": \"\",\n  \"recommendationPreferences\": \"\"\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=ComputeOptimizerService.GetEC2InstanceRecommendations";

    let payload = json!({
        "instanceArns": "",
        "nextToken": "",
        "maxResults": "",
        "filters": "",
        "accountIds": "",
        "recommendationPreferences": ""
    });

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

echo '{
  "instanceArns": "",
  "nextToken": "",
  "maxResults": "",
  "filters": "",
  "accountIds": "",
  "recommendationPreferences": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEC2InstanceRecommendations' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "instanceArns": "",\n  "nextToken": "",\n  "maxResults": "",\n  "filters": "",\n  "accountIds": "",\n  "recommendationPreferences": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEC2InstanceRecommendations'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "instanceArns": "",
  "nextToken": "",
  "maxResults": "",
  "filters": "",
  "accountIds": "",
  "recommendationPreferences": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEC2InstanceRecommendations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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  \"instanceArn\": \"\",\n  \"stat\": \"\",\n  \"period\": \"\",\n  \"startTime\": \"\",\n  \"endTime\": \"\",\n  \"recommendationPreferences\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEC2RecommendationProjectedMetrics" {:headers {:x-amz-target ""}
                                                                                                                       :content-type :json
                                                                                                                       :form-params {:instanceArn ""
                                                                                                                                     :stat ""
                                                                                                                                     :period ""
                                                                                                                                     :startTime ""
                                                                                                                                     :endTime ""
                                                                                                                                     :recommendationPreferences ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEC2RecommendationProjectedMetrics"

	payload := strings.NewReader("{\n  \"instanceArn\": \"\",\n  \"stat\": \"\",\n  \"period\": \"\",\n  \"startTime\": \"\",\n  \"endTime\": \"\",\n  \"recommendationPreferences\": \"\"\n}")

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

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

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

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

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

}

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

{
  "instanceArn": "",
  "stat": "",
  "period": "",
  "startTime": "",
  "endTime": "",
  "recommendationPreferences": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEC2RecommendationProjectedMetrics")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"instanceArn\": \"\",\n  \"stat\": \"\",\n  \"period\": \"\",\n  \"startTime\": \"\",\n  \"endTime\": \"\",\n  \"recommendationPreferences\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

const data = JSON.stringify({
  instanceArn: '',
  stat: '',
  period: '',
  startTime: '',
  endTime: '',
  recommendationPreferences: ''
});

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=ComputeOptimizerService.GetEC2RecommendationProjectedMetrics');
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=ComputeOptimizerService.GetEC2RecommendationProjectedMetrics',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    instanceArn: '',
    stat: '',
    period: '',
    startTime: '',
    endTime: '',
    recommendationPreferences: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEC2RecommendationProjectedMetrics';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"instanceArn":"","stat":"","period":"","startTime":"","endTime":"","recommendationPreferences":""}'
};

try {
  const response = await 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=ComputeOptimizerService.GetEC2RecommendationProjectedMetrics',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "instanceArn": "",\n  "stat": "",\n  "period": "",\n  "startTime": "",\n  "endTime": "",\n  "recommendationPreferences": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"instanceArn\": \"\",\n  \"stat\": \"\",\n  \"period\": \"\",\n  \"startTime\": \"\",\n  \"endTime\": \"\",\n  \"recommendationPreferences\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEC2RecommendationProjectedMetrics")
  .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({
  instanceArn: '',
  stat: '',
  period: '',
  startTime: '',
  endTime: '',
  recommendationPreferences: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEC2RecommendationProjectedMetrics',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    instanceArn: '',
    stat: '',
    period: '',
    startTime: '',
    endTime: '',
    recommendationPreferences: ''
  },
  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=ComputeOptimizerService.GetEC2RecommendationProjectedMetrics');

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

req.type('json');
req.send({
  instanceArn: '',
  stat: '',
  period: '',
  startTime: '',
  endTime: '',
  recommendationPreferences: ''
});

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=ComputeOptimizerService.GetEC2RecommendationProjectedMetrics',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    instanceArn: '',
    stat: '',
    period: '',
    startTime: '',
    endTime: '',
    recommendationPreferences: ''
  }
};

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=ComputeOptimizerService.GetEC2RecommendationProjectedMetrics';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"instanceArn":"","stat":"","period":"","startTime":"","endTime":"","recommendationPreferences":""}'
};

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 = @{ @"instanceArn": @"",
                              @"stat": @"",
                              @"period": @"",
                              @"startTime": @"",
                              @"endTime": @"",
                              @"recommendationPreferences": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEC2RecommendationProjectedMetrics",
  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([
    'instanceArn' => '',
    'stat' => '',
    'period' => '',
    'startTime' => '',
    'endTime' => '',
    'recommendationPreferences' => ''
  ]),
  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=ComputeOptimizerService.GetEC2RecommendationProjectedMetrics', [
  'body' => '{
  "instanceArn": "",
  "stat": "",
  "period": "",
  "startTime": "",
  "endTime": "",
  "recommendationPreferences": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'instanceArn' => '',
  'stat' => '',
  'period' => '',
  'startTime' => '',
  'endTime' => '',
  'recommendationPreferences' => ''
]));

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

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

append(json_encode([
  'instanceArn' => '',
  'stat' => '',
  'period' => '',
  'startTime' => '',
  'endTime' => '',
  'recommendationPreferences' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEC2RecommendationProjectedMetrics');
$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=ComputeOptimizerService.GetEC2RecommendationProjectedMetrics' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "instanceArn": "",
  "stat": "",
  "period": "",
  "startTime": "",
  "endTime": "",
  "recommendationPreferences": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEC2RecommendationProjectedMetrics' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "instanceArn": "",
  "stat": "",
  "period": "",
  "startTime": "",
  "endTime": "",
  "recommendationPreferences": ""
}'

import http.client

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

payload = "{\n  \"instanceArn\": \"\",\n  \"stat\": \"\",\n  \"period\": \"\",\n  \"startTime\": \"\",\n  \"endTime\": \"\",\n  \"recommendationPreferences\": \"\"\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=ComputeOptimizerService.GetEC2RecommendationProjectedMetrics"

payload = {
    "instanceArn": "",
    "stat": "",
    "period": "",
    "startTime": "",
    "endTime": "",
    "recommendationPreferences": ""
}
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=ComputeOptimizerService.GetEC2RecommendationProjectedMetrics"

payload <- "{\n  \"instanceArn\": \"\",\n  \"stat\": \"\",\n  \"period\": \"\",\n  \"startTime\": \"\",\n  \"endTime\": \"\",\n  \"recommendationPreferences\": \"\"\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=ComputeOptimizerService.GetEC2RecommendationProjectedMetrics")

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  \"instanceArn\": \"\",\n  \"stat\": \"\",\n  \"period\": \"\",\n  \"startTime\": \"\",\n  \"endTime\": \"\",\n  \"recommendationPreferences\": \"\"\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  \"instanceArn\": \"\",\n  \"stat\": \"\",\n  \"period\": \"\",\n  \"startTime\": \"\",\n  \"endTime\": \"\",\n  \"recommendationPreferences\": \"\"\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=ComputeOptimizerService.GetEC2RecommendationProjectedMetrics";

    let payload = json!({
        "instanceArn": "",
        "stat": "",
        "period": "",
        "startTime": "",
        "endTime": "",
        "recommendationPreferences": ""
    });

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

echo '{
  "instanceArn": "",
  "stat": "",
  "period": "",
  "startTime": "",
  "endTime": "",
  "recommendationPreferences": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEC2RecommendationProjectedMetrics' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "instanceArn": "",\n  "stat": "",\n  "period": "",\n  "startTime": "",\n  "endTime": "",\n  "recommendationPreferences": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEC2RecommendationProjectedMetrics'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "instanceArn": "",
  "stat": "",
  "period": "",
  "startTime": "",
  "endTime": "",
  "recommendationPreferences": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEC2RecommendationProjectedMetrics")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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  \"serviceArn\": \"\",\n  \"stat\": \"\",\n  \"period\": \"\",\n  \"startTime\": \"\",\n  \"endTime\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetECSServiceRecommendationProjectedMetrics" {:headers {:x-amz-target ""}
                                                                                                                              :content-type :json
                                                                                                                              :form-params {:serviceArn ""
                                                                                                                                            :stat ""
                                                                                                                                            :period ""
                                                                                                                                            :startTime ""
                                                                                                                                            :endTime ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetECSServiceRecommendationProjectedMetrics"

	payload := strings.NewReader("{\n  \"serviceArn\": \"\",\n  \"stat\": \"\",\n  \"period\": \"\",\n  \"startTime\": \"\",\n  \"endTime\": \"\"\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

{
  "serviceArn": "",
  "stat": "",
  "period": "",
  "startTime": "",
  "endTime": ""
}

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

client.close();

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

const data = JSON.stringify({
  serviceArn: '',
  stat: '',
  period: '',
  startTime: '',
  endTime: ''
});

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=ComputeOptimizerService.GetECSServiceRecommendationProjectedMetrics');
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=ComputeOptimizerService.GetECSServiceRecommendationProjectedMetrics',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {serviceArn: '', stat: '', period: '', startTime: '', endTime: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetECSServiceRecommendationProjectedMetrics';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"serviceArn":"","stat":"","period":"","startTime":"","endTime":""}'
};

try {
  const response = await 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=ComputeOptimizerService.GetECSServiceRecommendationProjectedMetrics',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "serviceArn": "",\n  "stat": "",\n  "period": "",\n  "startTime": "",\n  "endTime": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetECSServiceRecommendationProjectedMetrics',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {serviceArn: '', stat: '', period: '', startTime: '', endTime: ''},
  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=ComputeOptimizerService.GetECSServiceRecommendationProjectedMetrics');

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

req.type('json');
req.send({
  serviceArn: '',
  stat: '',
  period: '',
  startTime: '',
  endTime: ''
});

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=ComputeOptimizerService.GetECSServiceRecommendationProjectedMetrics',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {serviceArn: '', stat: '', period: '', startTime: '', endTime: ''}
};

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=ComputeOptimizerService.GetECSServiceRecommendationProjectedMetrics';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"serviceArn":"","stat":"","period":"","startTime":"","endTime":""}'
};

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 = @{ @"serviceArn": @"",
                              @"stat": @"",
                              @"period": @"",
                              @"startTime": @"",
                              @"endTime": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetECSServiceRecommendationProjectedMetrics",
  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([
    'serviceArn' => '',
    'stat' => '',
    'period' => '',
    'startTime' => '',
    'endTime' => ''
  ]),
  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=ComputeOptimizerService.GetECSServiceRecommendationProjectedMetrics', [
  'body' => '{
  "serviceArn": "",
  "stat": "",
  "period": "",
  "startTime": "",
  "endTime": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'serviceArn' => '',
  'stat' => '',
  'period' => '',
  'startTime' => '',
  'endTime' => ''
]));

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

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

append(json_encode([
  'serviceArn' => '',
  'stat' => '',
  'period' => '',
  'startTime' => '',
  'endTime' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetECSServiceRecommendationProjectedMetrics');
$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=ComputeOptimizerService.GetECSServiceRecommendationProjectedMetrics' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "serviceArn": "",
  "stat": "",
  "period": "",
  "startTime": "",
  "endTime": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetECSServiceRecommendationProjectedMetrics' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "serviceArn": "",
  "stat": "",
  "period": "",
  "startTime": "",
  "endTime": ""
}'

import http.client

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

payload = "{\n  \"serviceArn\": \"\",\n  \"stat\": \"\",\n  \"period\": \"\",\n  \"startTime\": \"\",\n  \"endTime\": \"\"\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=ComputeOptimizerService.GetECSServiceRecommendationProjectedMetrics"

payload = {
    "serviceArn": "",
    "stat": "",
    "period": "",
    "startTime": "",
    "endTime": ""
}
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=ComputeOptimizerService.GetECSServiceRecommendationProjectedMetrics"

payload <- "{\n  \"serviceArn\": \"\",\n  \"stat\": \"\",\n  \"period\": \"\",\n  \"startTime\": \"\",\n  \"endTime\": \"\"\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=ComputeOptimizerService.GetECSServiceRecommendationProjectedMetrics")

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  \"serviceArn\": \"\",\n  \"stat\": \"\",\n  \"period\": \"\",\n  \"startTime\": \"\",\n  \"endTime\": \"\"\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  \"serviceArn\": \"\",\n  \"stat\": \"\",\n  \"period\": \"\",\n  \"startTime\": \"\",\n  \"endTime\": \"\"\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=ComputeOptimizerService.GetECSServiceRecommendationProjectedMetrics";

    let payload = json!({
        "serviceArn": "",
        "stat": "",
        "period": "",
        "startTime": "",
        "endTime": ""
    });

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

echo '{
  "serviceArn": "",
  "stat": "",
  "period": "",
  "startTime": "",
  "endTime": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetECSServiceRecommendationProjectedMetrics' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "serviceArn": "",\n  "stat": "",\n  "period": "",\n  "startTime": "",\n  "endTime": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetECSServiceRecommendationProjectedMetrics'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "serviceArn": "",
  "stat": "",
  "period": "",
  "startTime": "",
  "endTime": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetECSServiceRecommendationProjectedMetrics")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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  \"serviceArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"accountIds\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetECSServiceRecommendations" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:serviceArns ""
                                                                                                                             :nextToken ""
                                                                                                                             :maxResults ""
                                                                                                                             :filters ""
                                                                                                                             :accountIds ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetECSServiceRecommendations"

	payload := strings.NewReader("{\n  \"serviceArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"accountIds\": \"\"\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: 99

{
  "serviceArns": "",
  "nextToken": "",
  "maxResults": "",
  "filters": "",
  "accountIds": ""
}

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

client.close();

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

const data = JSON.stringify({
  serviceArns: '',
  nextToken: '',
  maxResults: '',
  filters: '',
  accountIds: ''
});

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=ComputeOptimizerService.GetECSServiceRecommendations');
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=ComputeOptimizerService.GetECSServiceRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {serviceArns: '', nextToken: '', maxResults: '', filters: '', accountIds: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetECSServiceRecommendations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"serviceArns":"","nextToken":"","maxResults":"","filters":"","accountIds":""}'
};

try {
  const response = await 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=ComputeOptimizerService.GetECSServiceRecommendations',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "serviceArns": "",\n  "nextToken": "",\n  "maxResults": "",\n  "filters": "",\n  "accountIds": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetECSServiceRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {serviceArns: '', nextToken: '', maxResults: '', filters: '', accountIds: ''},
  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=ComputeOptimizerService.GetECSServiceRecommendations');

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

req.type('json');
req.send({
  serviceArns: '',
  nextToken: '',
  maxResults: '',
  filters: '',
  accountIds: ''
});

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=ComputeOptimizerService.GetECSServiceRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {serviceArns: '', nextToken: '', maxResults: '', filters: '', accountIds: ''}
};

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=ComputeOptimizerService.GetECSServiceRecommendations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"serviceArns":"","nextToken":"","maxResults":"","filters":"","accountIds":""}'
};

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 = @{ @"serviceArns": @"",
                              @"nextToken": @"",
                              @"maxResults": @"",
                              @"filters": @"",
                              @"accountIds": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetECSServiceRecommendations",
  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([
    'serviceArns' => '',
    'nextToken' => '',
    'maxResults' => '',
    'filters' => '',
    'accountIds' => ''
  ]),
  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=ComputeOptimizerService.GetECSServiceRecommendations', [
  'body' => '{
  "serviceArns": "",
  "nextToken": "",
  "maxResults": "",
  "filters": "",
  "accountIds": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'serviceArns' => '',
  'nextToken' => '',
  'maxResults' => '',
  'filters' => '',
  'accountIds' => ''
]));

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

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

append(json_encode([
  'serviceArns' => '',
  'nextToken' => '',
  'maxResults' => '',
  'filters' => '',
  'accountIds' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetECSServiceRecommendations');
$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=ComputeOptimizerService.GetECSServiceRecommendations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "serviceArns": "",
  "nextToken": "",
  "maxResults": "",
  "filters": "",
  "accountIds": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetECSServiceRecommendations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "serviceArns": "",
  "nextToken": "",
  "maxResults": "",
  "filters": "",
  "accountIds": ""
}'

import http.client

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

payload = "{\n  \"serviceArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"accountIds\": \"\"\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=ComputeOptimizerService.GetECSServiceRecommendations"

payload = {
    "serviceArns": "",
    "nextToken": "",
    "maxResults": "",
    "filters": "",
    "accountIds": ""
}
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=ComputeOptimizerService.GetECSServiceRecommendations"

payload <- "{\n  \"serviceArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"accountIds\": \"\"\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=ComputeOptimizerService.GetECSServiceRecommendations")

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  \"serviceArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"accountIds\": \"\"\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  \"serviceArns\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\",\n  \"filters\": \"\",\n  \"accountIds\": \"\"\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=ComputeOptimizerService.GetECSServiceRecommendations";

    let payload = json!({
        "serviceArns": "",
        "nextToken": "",
        "maxResults": "",
        "filters": "",
        "accountIds": ""
    });

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

echo '{
  "serviceArns": "",
  "nextToken": "",
  "maxResults": "",
  "filters": "",
  "accountIds": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetECSServiceRecommendations' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "serviceArns": "",\n  "nextToken": "",\n  "maxResults": "",\n  "filters": "",\n  "accountIds": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetECSServiceRecommendations'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "serviceArns": "",
  "nextToken": "",
  "maxResults": "",
  "filters": "",
  "accountIds": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetECSServiceRecommendations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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=ComputeOptimizerService.GetEffectiveRecommendationPreferences" {:headers {:x-amz-target ""}
                                                                                                                        :content-type :json
                                                                                                                        :form-params {:resourceArn ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEffectiveRecommendationPreferences"
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=ComputeOptimizerService.GetEffectiveRecommendationPreferences"),
    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=ComputeOptimizerService.GetEffectiveRecommendationPreferences");
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=ComputeOptimizerService.GetEffectiveRecommendationPreferences"

	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=ComputeOptimizerService.GetEffectiveRecommendationPreferences")
  .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=ComputeOptimizerService.GetEffectiveRecommendationPreferences"))
    .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=ComputeOptimizerService.GetEffectiveRecommendationPreferences")
  .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=ComputeOptimizerService.GetEffectiveRecommendationPreferences")
  .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=ComputeOptimizerService.GetEffectiveRecommendationPreferences');
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=ComputeOptimizerService.GetEffectiveRecommendationPreferences',
  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=ComputeOptimizerService.GetEffectiveRecommendationPreferences';
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=ComputeOptimizerService.GetEffectiveRecommendationPreferences',
  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=ComputeOptimizerService.GetEffectiveRecommendationPreferences")
  .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=ComputeOptimizerService.GetEffectiveRecommendationPreferences',
  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=ComputeOptimizerService.GetEffectiveRecommendationPreferences');

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=ComputeOptimizerService.GetEffectiveRecommendationPreferences',
  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=ComputeOptimizerService.GetEffectiveRecommendationPreferences';
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=ComputeOptimizerService.GetEffectiveRecommendationPreferences"]
                                                       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=ComputeOptimizerService.GetEffectiveRecommendationPreferences" 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=ComputeOptimizerService.GetEffectiveRecommendationPreferences",
  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=ComputeOptimizerService.GetEffectiveRecommendationPreferences', [
  'body' => '{
  "resourceArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEffectiveRecommendationPreferences');
$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=ComputeOptimizerService.GetEffectiveRecommendationPreferences');
$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=ComputeOptimizerService.GetEffectiveRecommendationPreferences' -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=ComputeOptimizerService.GetEffectiveRecommendationPreferences' -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=ComputeOptimizerService.GetEffectiveRecommendationPreferences"

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=ComputeOptimizerService.GetEffectiveRecommendationPreferences"

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=ComputeOptimizerService.GetEffectiveRecommendationPreferences")

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=ComputeOptimizerService.GetEffectiveRecommendationPreferences";

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

echo '{
  "resourceArn": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEffectiveRecommendationPreferences' \
  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=ComputeOptimizerService.GetEffectiveRecommendationPreferences'

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=ComputeOptimizerService.GetEffectiveRecommendationPreferences")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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=ComputeOptimizerService.GetEnrollmentStatus" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEnrollmentStatus"
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=ComputeOptimizerService.GetEnrollmentStatus"),
    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=ComputeOptimizerService.GetEnrollmentStatus");
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=ComputeOptimizerService.GetEnrollmentStatus"

	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=ComputeOptimizerService.GetEnrollmentStatus")
  .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=ComputeOptimizerService.GetEnrollmentStatus"))
    .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=ComputeOptimizerService.GetEnrollmentStatus")
  .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=ComputeOptimizerService.GetEnrollmentStatus")
  .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=ComputeOptimizerService.GetEnrollmentStatus');
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=ComputeOptimizerService.GetEnrollmentStatus',
  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=ComputeOptimizerService.GetEnrollmentStatus';
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=ComputeOptimizerService.GetEnrollmentStatus',
  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=ComputeOptimizerService.GetEnrollmentStatus")
  .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=ComputeOptimizerService.GetEnrollmentStatus',
  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=ComputeOptimizerService.GetEnrollmentStatus');

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=ComputeOptimizerService.GetEnrollmentStatus',
  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=ComputeOptimizerService.GetEnrollmentStatus';
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=ComputeOptimizerService.GetEnrollmentStatus"]
                                                       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=ComputeOptimizerService.GetEnrollmentStatus" 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=ComputeOptimizerService.GetEnrollmentStatus",
  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=ComputeOptimizerService.GetEnrollmentStatus', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEnrollmentStatus');
$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=ComputeOptimizerService.GetEnrollmentStatus');
$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=ComputeOptimizerService.GetEnrollmentStatus' -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=ComputeOptimizerService.GetEnrollmentStatus' -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=ComputeOptimizerService.GetEnrollmentStatus"

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=ComputeOptimizerService.GetEnrollmentStatus"

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=ComputeOptimizerService.GetEnrollmentStatus")

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=ComputeOptimizerService.GetEnrollmentStatus";

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

echo '{}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEnrollmentStatus' \
  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=ComputeOptimizerService.GetEnrollmentStatus'

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=ComputeOptimizerService.GetEnrollmentStatus")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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  \"filters\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEnrollmentStatusesForOrganization" {:headers {:x-amz-target ""}
                                                                                                                       :content-type :json
                                                                                                                       :form-params {:filters ""
                                                                                                                                     :nextToken ""
                                                                                                                                     :maxResults ""}})

require "http/client"

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

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

{
  "filters": "",
  "nextToken": "",
  "maxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEnrollmentStatusesForOrganization")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"filters\": \"\",\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=ComputeOptimizerService.GetEnrollmentStatusesForOrganization"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"filters\": \"\",\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  \"filters\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEnrollmentStatusesForOrganization")
  .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=ComputeOptimizerService.GetEnrollmentStatusesForOrganization")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"filters\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  filters: '',
  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=ComputeOptimizerService.GetEnrollmentStatusesForOrganization');
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=ComputeOptimizerService.GetEnrollmentStatusesForOrganization',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {filters: '', nextToken: '', maxResults: ''}
};

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

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

const request = require('request');

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

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

req.type('json');
req.send({
  filters: '',
  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=ComputeOptimizerService.GetEnrollmentStatusesForOrganization',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {filters: '', 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=ComputeOptimizerService.GetEnrollmentStatusesForOrganization';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"filters":"","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 = @{ @"filters": @"",
                              @"nextToken": @"",
                              @"maxResults": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEnrollmentStatusesForOrganization"]
                                                       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=ComputeOptimizerService.GetEnrollmentStatusesForOrganization" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"filters\": \"\",\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=ComputeOptimizerService.GetEnrollmentStatusesForOrganization",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'filters' => '',
    '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=ComputeOptimizerService.GetEnrollmentStatusesForOrganization', [
  'body' => '{
  "filters": "",
  "nextToken": "",
  "maxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'filters' => '',
  'nextToken' => '',
  'maxResults' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"filters\": \"\",\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=ComputeOptimizerService.GetEnrollmentStatusesForOrganization"

payload = {
    "filters": "",
    "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=ComputeOptimizerService.GetEnrollmentStatusesForOrganization"

payload <- "{\n  \"filters\": \"\",\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=ComputeOptimizerService.GetEnrollmentStatusesForOrganization")

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  \"filters\": \"\",\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  \"filters\": \"\",\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=ComputeOptimizerService.GetEnrollmentStatusesForOrganization";

    let payload = json!({
        "filters": "",
        "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);
}

echo '{
  "filters": "",
  "nextToken": "",
  "maxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEnrollmentStatusesForOrganization' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "filters": "",\n  "nextToken": "",\n  "maxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEnrollmentStatusesForOrganization'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetEnrollmentStatusesForOrganization")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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  \"functionArns\": \"\",\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetLambdaFunctionRecommendations" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:functionArns ""
                                                                                                                                 :accountIds ""
                                                                                                                                 :filters ""
                                                                                                                                 :nextToken ""
                                                                                                                                 :maxResults ""}})

require "http/client"

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

	payload := strings.NewReader("{\n  \"functionArns\": \"\",\n  \"accountIds\": \"\",\n  \"filters\": \"\",\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: 100

{
  "functionArns": "",
  "accountIds": "",
  "filters": "",
  "nextToken": "",
  "maxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetLambdaFunctionRecommendations")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"functionArns\": \"\",\n  \"accountIds\": \"\",\n  \"filters\": \"\",\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=ComputeOptimizerService.GetLambdaFunctionRecommendations"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"functionArns\": \"\",\n  \"accountIds\": \"\",\n  \"filters\": \"\",\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  \"functionArns\": \"\",\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetLambdaFunctionRecommendations")
  .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=ComputeOptimizerService.GetLambdaFunctionRecommendations")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"functionArns\": \"\",\n  \"accountIds\": \"\",\n  \"filters\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  functionArns: '',
  accountIds: '',
  filters: '',
  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=ComputeOptimizerService.GetLambdaFunctionRecommendations');
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=ComputeOptimizerService.GetLambdaFunctionRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {functionArns: '', accountIds: '', filters: '', nextToken: '', maxResults: ''}
};

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

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

const request = require('request');

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

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

req.type('json');
req.send({
  functionArns: '',
  accountIds: '',
  filters: '',
  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=ComputeOptimizerService.GetLambdaFunctionRecommendations',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {functionArns: '', accountIds: '', filters: '', 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=ComputeOptimizerService.GetLambdaFunctionRecommendations';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"functionArns":"","accountIds":"","filters":"","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 = @{ @"functionArns": @"",
                              @"accountIds": @"",
                              @"filters": @"",
                              @"nextToken": @"",
                              @"maxResults": @"" };

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'functionArns' => '',
  'accountIds' => '',
  'filters' => '',
  'nextToken' => '',
  'maxResults' => ''
]));

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

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

append(json_encode([
  'functionArns' => '',
  'accountIds' => '',
  'filters' => '',
  'nextToken' => '',
  'maxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetLambdaFunctionRecommendations');
$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=ComputeOptimizerService.GetLambdaFunctionRecommendations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "functionArns": "",
  "accountIds": "",
  "filters": "",
  "nextToken": "",
  "maxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetLambdaFunctionRecommendations' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "functionArns": "",
  "accountIds": "",
  "filters": "",
  "nextToken": "",
  "maxResults": ""
}'

import http.client

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

payload = "{\n  \"functionArns\": \"\",\n  \"accountIds\": \"\",\n  \"filters\": \"\",\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=ComputeOptimizerService.GetLambdaFunctionRecommendations"

payload = {
    "functionArns": "",
    "accountIds": "",
    "filters": "",
    "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=ComputeOptimizerService.GetLambdaFunctionRecommendations"

payload <- "{\n  \"functionArns\": \"\",\n  \"accountIds\": \"\",\n  \"filters\": \"\",\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=ComputeOptimizerService.GetLambdaFunctionRecommendations")

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  \"functionArns\": \"\",\n  \"accountIds\": \"\",\n  \"filters\": \"\",\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  \"functionArns\": \"\",\n  \"accountIds\": \"\",\n  \"filters\": \"\",\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=ComputeOptimizerService.GetLambdaFunctionRecommendations";

    let payload = json!({
        "functionArns": "",
        "accountIds": "",
        "filters": "",
        "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);
}

echo '{
  "functionArns": "",
  "accountIds": "",
  "filters": "",
  "nextToken": "",
  "maxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetLambdaFunctionRecommendations' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "functionArns": "",\n  "accountIds": "",\n  "filters": "",\n  "nextToken": "",\n  "maxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetLambdaFunctionRecommendations'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "functionArns": "",
  "accountIds": "",
  "filters": "",
  "nextToken": "",
  "maxResults": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetLambdaFunctionRecommendations")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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  \"resourceType\": \"\",\n  \"scope\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetRecommendationPreferences" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:resourceType ""
                                                                                                                             :scope ""
                                                                                                                             :nextToken ""
                                                                                                                             :maxResults ""}})

require "http/client"

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

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

{
  "resourceType": "",
  "scope": "",
  "nextToken": "",
  "maxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetRecommendationPreferences")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resourceType\": \"\",\n  \"scope\": \"\",\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=ComputeOptimizerService.GetRecommendationPreferences"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"resourceType\": \"\",\n  \"scope\": \"\",\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  \"resourceType\": \"\",\n  \"scope\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetRecommendationPreferences")
  .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=ComputeOptimizerService.GetRecommendationPreferences")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"resourceType\": \"\",\n  \"scope\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  resourceType: '',
  scope: '',
  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=ComputeOptimizerService.GetRecommendationPreferences');
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=ComputeOptimizerService.GetRecommendationPreferences',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {resourceType: '', scope: '', nextToken: '', maxResults: ''}
};

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

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

const request = require('request');

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

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

req.type('json');
req.send({
  resourceType: '',
  scope: '',
  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=ComputeOptimizerService.GetRecommendationPreferences',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {resourceType: '', scope: '', 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=ComputeOptimizerService.GetRecommendationPreferences';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"resourceType":"","scope":"","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 = @{ @"resourceType": @"",
                              @"scope": @"",
                              @"nextToken": @"",
                              @"maxResults": @"" };

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resourceType' => '',
  'scope' => '',
  'nextToken' => '',
  'maxResults' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"resourceType\": \"\",\n  \"scope\": \"\",\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=ComputeOptimizerService.GetRecommendationPreferences"

payload = {
    "resourceType": "",
    "scope": "",
    "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=ComputeOptimizerService.GetRecommendationPreferences"

payload <- "{\n  \"resourceType\": \"\",\n  \"scope\": \"\",\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=ComputeOptimizerService.GetRecommendationPreferences")

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  \"resourceType\": \"\",\n  \"scope\": \"\",\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  \"resourceType\": \"\",\n  \"scope\": \"\",\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=ComputeOptimizerService.GetRecommendationPreferences";

    let payload = json!({
        "resourceType": "",
        "scope": "",
        "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);
}

echo '{
  "resourceType": "",
  "scope": "",
  "nextToken": "",
  "maxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetRecommendationPreferences' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourceType": "",\n  "scope": "",\n  "nextToken": "",\n  "maxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetRecommendationPreferences'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetRecommendationPreferences")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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  \"accountIds\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetRecommendationSummaries" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:accountIds ""
                                                                                                                           :nextToken ""
                                                                                                                           :maxResults ""}})

require "http/client"

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

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

{
  "accountIds": "",
  "nextToken": "",
  "maxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetRecommendationSummaries")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"accountIds\": \"\",\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=ComputeOptimizerService.GetRecommendationSummaries"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"accountIds\": \"\",\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  \"accountIds\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetRecommendationSummaries")
  .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=ComputeOptimizerService.GetRecommendationSummaries")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"accountIds\": \"\",\n  \"nextToken\": \"\",\n  \"maxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  accountIds: '',
  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=ComputeOptimizerService.GetRecommendationSummaries');
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=ComputeOptimizerService.GetRecommendationSummaries',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {accountIds: '', nextToken: '', maxResults: ''}
};

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

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

const request = require('request');

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

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

req.type('json');
req.send({
  accountIds: '',
  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=ComputeOptimizerService.GetRecommendationSummaries',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {accountIds: '', 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=ComputeOptimizerService.GetRecommendationSummaries';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"accountIds":"","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 = @{ @"accountIds": @"",
                              @"nextToken": @"",
                              @"maxResults": @"" };

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'accountIds' => '',
  'nextToken' => '',
  'maxResults' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"accountIds\": \"\",\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=ComputeOptimizerService.GetRecommendationSummaries"

payload = {
    "accountIds": "",
    "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=ComputeOptimizerService.GetRecommendationSummaries"

payload <- "{\n  \"accountIds\": \"\",\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=ComputeOptimizerService.GetRecommendationSummaries")

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  \"accountIds\": \"\",\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  \"accountIds\": \"\",\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=ComputeOptimizerService.GetRecommendationSummaries";

    let payload = json!({
        "accountIds": "",
        "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);
}

echo '{
  "accountIds": "",
  "nextToken": "",
  "maxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetRecommendationSummaries' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "accountIds": "",\n  "nextToken": "",\n  "maxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetRecommendationSummaries'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.GetRecommendationSummaries")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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  \"resourceType\": \"\",\n  \"scope\": \"\",\n  \"enhancedInfrastructureMetrics\": \"\",\n  \"inferredWorkloadTypes\": \"\",\n  \"externalMetricsPreference\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.PutRecommendationPreferences" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:resourceType ""
                                                                                                                             :scope ""
                                                                                                                             :enhancedInfrastructureMetrics ""
                                                                                                                             :inferredWorkloadTypes ""
                                                                                                                             :externalMetricsPreference ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.PutRecommendationPreferences"

	payload := strings.NewReader("{\n  \"resourceType\": \"\",\n  \"scope\": \"\",\n  \"enhancedInfrastructureMetrics\": \"\",\n  \"inferredWorkloadTypes\": \"\",\n  \"externalMetricsPreference\": \"\"\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: 144

{
  "resourceType": "",
  "scope": "",
  "enhancedInfrastructureMetrics": "",
  "inferredWorkloadTypes": "",
  "externalMetricsPreference": ""
}

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

client.close();

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

const data = JSON.stringify({
  resourceType: '',
  scope: '',
  enhancedInfrastructureMetrics: '',
  inferredWorkloadTypes: '',
  externalMetricsPreference: ''
});

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=ComputeOptimizerService.PutRecommendationPreferences');
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=ComputeOptimizerService.PutRecommendationPreferences',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    resourceType: '',
    scope: '',
    enhancedInfrastructureMetrics: '',
    inferredWorkloadTypes: '',
    externalMetricsPreference: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.PutRecommendationPreferences';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"resourceType":"","scope":"","enhancedInfrastructureMetrics":"","inferredWorkloadTypes":"","externalMetricsPreference":""}'
};

try {
  const response = await 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=ComputeOptimizerService.PutRecommendationPreferences',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resourceType": "",\n  "scope": "",\n  "enhancedInfrastructureMetrics": "",\n  "inferredWorkloadTypes": "",\n  "externalMetricsPreference": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.PutRecommendationPreferences',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    resourceType: '',
    scope: '',
    enhancedInfrastructureMetrics: '',
    inferredWorkloadTypes: '',
    externalMetricsPreference: ''
  },
  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=ComputeOptimizerService.PutRecommendationPreferences');

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

req.type('json');
req.send({
  resourceType: '',
  scope: '',
  enhancedInfrastructureMetrics: '',
  inferredWorkloadTypes: '',
  externalMetricsPreference: ''
});

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=ComputeOptimizerService.PutRecommendationPreferences',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    resourceType: '',
    scope: '',
    enhancedInfrastructureMetrics: '',
    inferredWorkloadTypes: '',
    externalMetricsPreference: ''
  }
};

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=ComputeOptimizerService.PutRecommendationPreferences';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"resourceType":"","scope":"","enhancedInfrastructureMetrics":"","inferredWorkloadTypes":"","externalMetricsPreference":""}'
};

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 = @{ @"resourceType": @"",
                              @"scope": @"",
                              @"enhancedInfrastructureMetrics": @"",
                              @"inferredWorkloadTypes": @"",
                              @"externalMetricsPreference": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.PutRecommendationPreferences",
  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([
    'resourceType' => '',
    'scope' => '',
    'enhancedInfrastructureMetrics' => '',
    'inferredWorkloadTypes' => '',
    'externalMetricsPreference' => ''
  ]),
  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=ComputeOptimizerService.PutRecommendationPreferences', [
  'body' => '{
  "resourceType": "",
  "scope": "",
  "enhancedInfrastructureMetrics": "",
  "inferredWorkloadTypes": "",
  "externalMetricsPreference": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resourceType' => '',
  'scope' => '',
  'enhancedInfrastructureMetrics' => '',
  'inferredWorkloadTypes' => '',
  'externalMetricsPreference' => ''
]));

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

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

append(json_encode([
  'resourceType' => '',
  'scope' => '',
  'enhancedInfrastructureMetrics' => '',
  'inferredWorkloadTypes' => '',
  'externalMetricsPreference' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.PutRecommendationPreferences');
$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=ComputeOptimizerService.PutRecommendationPreferences' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceType": "",
  "scope": "",
  "enhancedInfrastructureMetrics": "",
  "inferredWorkloadTypes": "",
  "externalMetricsPreference": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.PutRecommendationPreferences' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceType": "",
  "scope": "",
  "enhancedInfrastructureMetrics": "",
  "inferredWorkloadTypes": "",
  "externalMetricsPreference": ""
}'

import http.client

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

payload = "{\n  \"resourceType\": \"\",\n  \"scope\": \"\",\n  \"enhancedInfrastructureMetrics\": \"\",\n  \"inferredWorkloadTypes\": \"\",\n  \"externalMetricsPreference\": \"\"\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=ComputeOptimizerService.PutRecommendationPreferences"

payload = {
    "resourceType": "",
    "scope": "",
    "enhancedInfrastructureMetrics": "",
    "inferredWorkloadTypes": "",
    "externalMetricsPreference": ""
}
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=ComputeOptimizerService.PutRecommendationPreferences"

payload <- "{\n  \"resourceType\": \"\",\n  \"scope\": \"\",\n  \"enhancedInfrastructureMetrics\": \"\",\n  \"inferredWorkloadTypes\": \"\",\n  \"externalMetricsPreference\": \"\"\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=ComputeOptimizerService.PutRecommendationPreferences")

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  \"resourceType\": \"\",\n  \"scope\": \"\",\n  \"enhancedInfrastructureMetrics\": \"\",\n  \"inferredWorkloadTypes\": \"\",\n  \"externalMetricsPreference\": \"\"\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  \"resourceType\": \"\",\n  \"scope\": \"\",\n  \"enhancedInfrastructureMetrics\": \"\",\n  \"inferredWorkloadTypes\": \"\",\n  \"externalMetricsPreference\": \"\"\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=ComputeOptimizerService.PutRecommendationPreferences";

    let payload = json!({
        "resourceType": "",
        "scope": "",
        "enhancedInfrastructureMetrics": "",
        "inferredWorkloadTypes": "",
        "externalMetricsPreference": ""
    });

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

echo '{
  "resourceType": "",
  "scope": "",
  "enhancedInfrastructureMetrics": "",
  "inferredWorkloadTypes": "",
  "externalMetricsPreference": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.PutRecommendationPreferences' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourceType": "",\n  "scope": "",\n  "enhancedInfrastructureMetrics": "",\n  "inferredWorkloadTypes": "",\n  "externalMetricsPreference": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.PutRecommendationPreferences'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "resourceType": "",
  "scope": "",
  "enhancedInfrastructureMetrics": "",
  "inferredWorkloadTypes": "",
  "externalMetricsPreference": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.PutRecommendationPreferences")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

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

dataTask.resume()

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.UpdateEnrollmentStatus" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:status ""
                                                                                                                       :includeMemberAccounts ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.UpdateEnrollmentStatus"

	payload := strings.NewReader("{\n  \"status\": \"\",\n  \"includeMemberAccounts\": \"\"\n}")

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

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

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

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

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

}

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

{
  "status": "",
  "includeMemberAccounts": ""
}

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

client.close();

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

const data = JSON.stringify({
  status: '',
  includeMemberAccounts: ''
});

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=ComputeOptimizerService.UpdateEnrollmentStatus');
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=ComputeOptimizerService.UpdateEnrollmentStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {status: '', includeMemberAccounts: ''}
};

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

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

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

const request = require('request');

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

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

req.type('json');
req.send({
  status: '',
  includeMemberAccounts: ''
});

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=ComputeOptimizerService.UpdateEnrollmentStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {status: '', includeMemberAccounts: ''}
};

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

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.UpdateEnrollmentStatus"]
                                                       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=ComputeOptimizerService.UpdateEnrollmentStatus" 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  \"includeMemberAccounts\": \"\"\n}" in

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"status\": \"\",\n  \"includeMemberAccounts\": \"\"\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=ComputeOptimizerService.UpdateEnrollmentStatus"

payload = {
    "status": "",
    "includeMemberAccounts": ""
}
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=ComputeOptimizerService.UpdateEnrollmentStatus"

payload <- "{\n  \"status\": \"\",\n  \"includeMemberAccounts\": \"\"\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=ComputeOptimizerService.UpdateEnrollmentStatus")

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  \"includeMemberAccounts\": \"\"\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  \"includeMemberAccounts\": \"\"\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=ComputeOptimizerService.UpdateEnrollmentStatus";

    let payload = json!({
        "status": "",
        "includeMemberAccounts": ""
    });

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

echo '{
  "status": "",
  "includeMemberAccounts": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.UpdateEnrollmentStatus' \
  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  "includeMemberAccounts": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=ComputeOptimizerService.UpdateEnrollmentStatus'

import Foundation

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

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

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