AWS Proton

POST AcceptEnvironmentAccountConnection

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.AcceptEnvironmentAccountConnection

HEADERS

X-Amz-Target

BODY json

{
  "id": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.AcceptEnvironmentAccountConnection"

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

{
  "id": ""
}

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

client.close();

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

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

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

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

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

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=AwsProton20200720.AcceptEnvironmentAccountConnection',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"id\": \"\"\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=AwsProton20200720.AcceptEnvironmentAccountConnection"

payload = { "id": "" }
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=AwsProton20200720.AcceptEnvironmentAccountConnection"

payload <- "{\n  \"id\": \"\"\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=AwsProton20200720.AcceptEnvironmentAccountConnection")

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  \"id\": \"\"\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  \"id\": \"\"\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=AwsProton20200720.AcceptEnvironmentAccountConnection";

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.AcceptEnvironmentAccountConnection' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "id": ""
}'

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

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

import Foundation

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

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

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

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

dataTask.resume()

POST CancelComponentDeployment

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CancelComponentDeployment

HEADERS

X-Amz-Target

BODY json

{
  "componentName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CancelComponentDeployment"

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

{
  "componentName": ""
}

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

client.close();

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

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

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

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

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

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=AwsProton20200720.CancelComponentDeployment',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "componentName": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"componentName\": \"\"\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=AwsProton20200720.CancelComponentDeployment"

payload = { "componentName": "" }
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=AwsProton20200720.CancelComponentDeployment"

payload <- "{\n  \"componentName\": \"\"\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=AwsProton20200720.CancelComponentDeployment")

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  \"componentName\": \"\"\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  \"componentName\": \"\"\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=AwsProton20200720.CancelComponentDeployment";

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CancelComponentDeployment' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "componentName": ""
}'

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

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

import Foundation

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

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

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

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

dataTask.resume()

POST CancelEnvironmentDeployment

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CancelEnvironmentDeployment

HEADERS

X-Amz-Target

BODY json

{
  "environmentName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CancelEnvironmentDeployment"

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

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

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

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

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

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

}

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

{
  "environmentName": ""
}

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

client.close();

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

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

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

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

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

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=AwsProton20200720.CancelEnvironmentDeployment',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "environmentName": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"environmentName\": \"\"\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=AwsProton20200720.CancelEnvironmentDeployment"

payload = { "environmentName": "" }
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=AwsProton20200720.CancelEnvironmentDeployment"

payload <- "{\n  \"environmentName\": \"\"\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=AwsProton20200720.CancelEnvironmentDeployment")

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  \"environmentName\": \"\"\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  \"environmentName\": \"\"\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=AwsProton20200720.CancelEnvironmentDeployment";

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CancelEnvironmentDeployment' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "environmentName": ""
}'

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

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

import Foundation

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

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

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

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

dataTask.resume()

POST CancelServiceInstanceDeployment

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CancelServiceInstanceDeployment

HEADERS

X-Amz-Target

BODY json

{
  "serviceInstanceName": "",
  "serviceName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CancelServiceInstanceDeployment" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:serviceInstanceName ""
                                                                                                                          :serviceName ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CancelServiceInstanceDeployment"

	payload := strings.NewReader("{\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}")

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

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

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

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

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

}

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

{
  "serviceInstanceName": "",
  "serviceName": ""
}

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

client.close();

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

const data = JSON.stringify({
  serviceInstanceName: '',
  serviceName: ''
});

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=AwsProton20200720.CancelServiceInstanceDeployment');
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=AwsProton20200720.CancelServiceInstanceDeployment',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {serviceInstanceName: '', serviceName: ''}
};

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

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

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=AwsProton20200720.CancelServiceInstanceDeployment',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "serviceInstanceName": "",\n  "serviceName": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  serviceInstanceName: '',
  serviceName: ''
});

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=AwsProton20200720.CancelServiceInstanceDeployment',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {serviceInstanceName: '', serviceName: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.CancelServiceInstanceDeployment"

payload = {
    "serviceInstanceName": "",
    "serviceName": ""
}
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=AwsProton20200720.CancelServiceInstanceDeployment"

payload <- "{\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.CancelServiceInstanceDeployment")

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  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.CancelServiceInstanceDeployment";

    let payload = json!({
        "serviceInstanceName": "",
        "serviceName": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CancelServiceInstanceDeployment' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "serviceInstanceName": "",
  "serviceName": ""
}'

echo '{
  "serviceInstanceName": "",
  "serviceName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CancelServiceInstanceDeployment' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

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

dataTask.resume()

POST CancelServicePipelineDeployment

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CancelServicePipelineDeployment

HEADERS

X-Amz-Target

BODY json

{
  "serviceName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CancelServicePipelineDeployment"

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

{
  "serviceName": ""
}

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

client.close();

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

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

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

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

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

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=AwsProton20200720.CancelServicePipelineDeployment',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "serviceName": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"serviceName\": \"\"\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=AwsProton20200720.CancelServicePipelineDeployment"

payload = { "serviceName": "" }
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=AwsProton20200720.CancelServicePipelineDeployment"

payload <- "{\n  \"serviceName\": \"\"\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=AwsProton20200720.CancelServicePipelineDeployment")

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  \"serviceName\": \"\"\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  \"serviceName\": \"\"\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=AwsProton20200720.CancelServicePipelineDeployment";

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CancelServicePipelineDeployment' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "serviceName": ""
}'

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

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

import Foundation

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

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

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

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

dataTask.resume()

POST CreateComponent

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateComponent

HEADERS

X-Amz-Target

BODY json

{
  "clientToken": "",
  "description": "",
  "environmentName": "",
  "manifest": "",
  "name": "",
  "serviceInstanceName": "",
  "serviceName": "",
  "serviceSpec": "",
  "tags": "",
  "templateFile": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"clientToken\": \"\",\n  \"description\": \"\",\n  \"environmentName\": \"\",\n  \"manifest\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"tags\": \"\",\n  \"templateFile\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateComponent" {:headers {:x-amz-target ""}
                                                                                            :content-type :json
                                                                                            :form-params {:clientToken ""
                                                                                                          :description ""
                                                                                                          :environmentName ""
                                                                                                          :manifest ""
                                                                                                          :name ""
                                                                                                          :serviceInstanceName ""
                                                                                                          :serviceName ""
                                                                                                          :serviceSpec ""
                                                                                                          :tags ""
                                                                                                          :templateFile ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateComponent"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"clientToken\": \"\",\n  \"description\": \"\",\n  \"environmentName\": \"\",\n  \"manifest\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"tags\": \"\",\n  \"templateFile\": \"\"\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=AwsProton20200720.CreateComponent"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"clientToken\": \"\",\n  \"description\": \"\",\n  \"environmentName\": \"\",\n  \"manifest\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"tags\": \"\",\n  \"templateFile\": \"\"\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=AwsProton20200720.CreateComponent");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"clientToken\": \"\",\n  \"description\": \"\",\n  \"environmentName\": \"\",\n  \"manifest\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"tags\": \"\",\n  \"templateFile\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateComponent"

	payload := strings.NewReader("{\n  \"clientToken\": \"\",\n  \"description\": \"\",\n  \"environmentName\": \"\",\n  \"manifest\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"tags\": \"\",\n  \"templateFile\": \"\"\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: 208

{
  "clientToken": "",
  "description": "",
  "environmentName": "",
  "manifest": "",
  "name": "",
  "serviceInstanceName": "",
  "serviceName": "",
  "serviceSpec": "",
  "tags": "",
  "templateFile": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateComponent")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"clientToken\": \"\",\n  \"description\": \"\",\n  \"environmentName\": \"\",\n  \"manifest\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"tags\": \"\",\n  \"templateFile\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateComponent"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"clientToken\": \"\",\n  \"description\": \"\",\n  \"environmentName\": \"\",\n  \"manifest\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"tags\": \"\",\n  \"templateFile\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"clientToken\": \"\",\n  \"description\": \"\",\n  \"environmentName\": \"\",\n  \"manifest\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"tags\": \"\",\n  \"templateFile\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateComponent")
  .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=AwsProton20200720.CreateComponent")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"clientToken\": \"\",\n  \"description\": \"\",\n  \"environmentName\": \"\",\n  \"manifest\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"tags\": \"\",\n  \"templateFile\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  clientToken: '',
  description: '',
  environmentName: '',
  manifest: '',
  name: '',
  serviceInstanceName: '',
  serviceName: '',
  serviceSpec: '',
  tags: '',
  templateFile: ''
});

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=AwsProton20200720.CreateComponent');
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=AwsProton20200720.CreateComponent',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    clientToken: '',
    description: '',
    environmentName: '',
    manifest: '',
    name: '',
    serviceInstanceName: '',
    serviceName: '',
    serviceSpec: '',
    tags: '',
    templateFile: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateComponent';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"clientToken":"","description":"","environmentName":"","manifest":"","name":"","serviceInstanceName":"","serviceName":"","serviceSpec":"","tags":"","templateFile":""}'
};

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=AwsProton20200720.CreateComponent',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "clientToken": "",\n  "description": "",\n  "environmentName": "",\n  "manifest": "",\n  "name": "",\n  "serviceInstanceName": "",\n  "serviceName": "",\n  "serviceSpec": "",\n  "tags": "",\n  "templateFile": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"clientToken\": \"\",\n  \"description\": \"\",\n  \"environmentName\": \"\",\n  \"manifest\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"tags\": \"\",\n  \"templateFile\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateComponent")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  clientToken: '',
  description: '',
  environmentName: '',
  manifest: '',
  name: '',
  serviceInstanceName: '',
  serviceName: '',
  serviceSpec: '',
  tags: '',
  templateFile: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateComponent',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    clientToken: '',
    description: '',
    environmentName: '',
    manifest: '',
    name: '',
    serviceInstanceName: '',
    serviceName: '',
    serviceSpec: '',
    tags: '',
    templateFile: ''
  },
  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=AwsProton20200720.CreateComponent');

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

req.type('json');
req.send({
  clientToken: '',
  description: '',
  environmentName: '',
  manifest: '',
  name: '',
  serviceInstanceName: '',
  serviceName: '',
  serviceSpec: '',
  tags: '',
  templateFile: ''
});

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=AwsProton20200720.CreateComponent',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    clientToken: '',
    description: '',
    environmentName: '',
    manifest: '',
    name: '',
    serviceInstanceName: '',
    serviceName: '',
    serviceSpec: '',
    tags: '',
    templateFile: ''
  }
};

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=AwsProton20200720.CreateComponent';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"clientToken":"","description":"","environmentName":"","manifest":"","name":"","serviceInstanceName":"","serviceName":"","serviceSpec":"","tags":"","templateFile":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"clientToken": @"",
                              @"description": @"",
                              @"environmentName": @"",
                              @"manifest": @"",
                              @"name": @"",
                              @"serviceInstanceName": @"",
                              @"serviceName": @"",
                              @"serviceSpec": @"",
                              @"tags": @"",
                              @"templateFile": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateComponent"]
                                                       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=AwsProton20200720.CreateComponent" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"clientToken\": \"\",\n  \"description\": \"\",\n  \"environmentName\": \"\",\n  \"manifest\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"tags\": \"\",\n  \"templateFile\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateComponent",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'clientToken' => '',
    'description' => '',
    'environmentName' => '',
    'manifest' => '',
    'name' => '',
    'serviceInstanceName' => '',
    'serviceName' => '',
    'serviceSpec' => '',
    'tags' => '',
    'templateFile' => ''
  ]),
  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=AwsProton20200720.CreateComponent', [
  'body' => '{
  "clientToken": "",
  "description": "",
  "environmentName": "",
  "manifest": "",
  "name": "",
  "serviceInstanceName": "",
  "serviceName": "",
  "serviceSpec": "",
  "tags": "",
  "templateFile": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'clientToken' => '',
  'description' => '',
  'environmentName' => '',
  'manifest' => '',
  'name' => '',
  'serviceInstanceName' => '',
  'serviceName' => '',
  'serviceSpec' => '',
  'tags' => '',
  'templateFile' => ''
]));

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

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

append(json_encode([
  'clientToken' => '',
  'description' => '',
  'environmentName' => '',
  'manifest' => '',
  'name' => '',
  'serviceInstanceName' => '',
  'serviceName' => '',
  'serviceSpec' => '',
  'tags' => '',
  'templateFile' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateComponent');
$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=AwsProton20200720.CreateComponent' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "clientToken": "",
  "description": "",
  "environmentName": "",
  "manifest": "",
  "name": "",
  "serviceInstanceName": "",
  "serviceName": "",
  "serviceSpec": "",
  "tags": "",
  "templateFile": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateComponent' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "clientToken": "",
  "description": "",
  "environmentName": "",
  "manifest": "",
  "name": "",
  "serviceInstanceName": "",
  "serviceName": "",
  "serviceSpec": "",
  "tags": "",
  "templateFile": ""
}'

import http.client

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

payload = "{\n  \"clientToken\": \"\",\n  \"description\": \"\",\n  \"environmentName\": \"\",\n  \"manifest\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"tags\": \"\",\n  \"templateFile\": \"\"\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=AwsProton20200720.CreateComponent"

payload = {
    "clientToken": "",
    "description": "",
    "environmentName": "",
    "manifest": "",
    "name": "",
    "serviceInstanceName": "",
    "serviceName": "",
    "serviceSpec": "",
    "tags": "",
    "templateFile": ""
}
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=AwsProton20200720.CreateComponent"

payload <- "{\n  \"clientToken\": \"\",\n  \"description\": \"\",\n  \"environmentName\": \"\",\n  \"manifest\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"tags\": \"\",\n  \"templateFile\": \"\"\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=AwsProton20200720.CreateComponent")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"clientToken\": \"\",\n  \"description\": \"\",\n  \"environmentName\": \"\",\n  \"manifest\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"tags\": \"\",\n  \"templateFile\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"clientToken\": \"\",\n  \"description\": \"\",\n  \"environmentName\": \"\",\n  \"manifest\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"tags\": \"\",\n  \"templateFile\": \"\"\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=AwsProton20200720.CreateComponent";

    let payload = json!({
        "clientToken": "",
        "description": "",
        "environmentName": "",
        "manifest": "",
        "name": "",
        "serviceInstanceName": "",
        "serviceName": "",
        "serviceSpec": "",
        "tags": "",
        "templateFile": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateComponent' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "clientToken": "",
  "description": "",
  "environmentName": "",
  "manifest": "",
  "name": "",
  "serviceInstanceName": "",
  "serviceName": "",
  "serviceSpec": "",
  "tags": "",
  "templateFile": ""
}'

echo '{
  "clientToken": "",
  "description": "",
  "environmentName": "",
  "manifest": "",
  "name": "",
  "serviceInstanceName": "",
  "serviceName": "",
  "serviceSpec": "",
  "tags": "",
  "templateFile": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateComponent' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "clientToken": "",\n  "description": "",\n  "environmentName": "",\n  "manifest": "",\n  "name": "",\n  "serviceInstanceName": "",\n  "serviceName": "",\n  "serviceSpec": "",\n  "tags": "",\n  "templateFile": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateComponent'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "clientToken": "",
  "description": "",
  "environmentName": "",
  "manifest": "",
  "name": "",
  "serviceInstanceName": "",
  "serviceName": "",
  "serviceSpec": "",
  "tags": "",
  "templateFile": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST CreateEnvironment

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironment

HEADERS

X-Amz-Target

BODY json

{
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "description": "",
  "environmentAccountConnectionId": "",
  "name": "",
  "protonServiceRoleArn": "",
  "provisioningRepository": "",
  "spec": "",
  "tags": "",
  "templateMajorVersion": "",
  "templateMinorVersion": "",
  "templateName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironment" {:headers {:x-amz-target ""}
                                                                                              :content-type :json
                                                                                              :form-params {:codebuildRoleArn ""
                                                                                                            :componentRoleArn ""
                                                                                                            :description ""
                                                                                                            :environmentAccountConnectionId ""
                                                                                                            :name ""
                                                                                                            :protonServiceRoleArn ""
                                                                                                            :provisioningRepository ""
                                                                                                            :spec ""
                                                                                                            :tags ""
                                                                                                            :templateMajorVersion ""
                                                                                                            :templateMinorVersion ""
                                                                                                            :templateName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironment"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.CreateEnvironment"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.CreateEnvironment");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironment"

	payload := strings.NewReader("{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\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: 301

{
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "description": "",
  "environmentAccountConnectionId": "",
  "name": "",
  "protonServiceRoleArn": "",
  "provisioningRepository": "",
  "spec": "",
  "tags": "",
  "templateMajorVersion": "",
  "templateMinorVersion": "",
  "templateName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironment")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironment"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\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  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironment")
  .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=AwsProton20200720.CreateEnvironment")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  codebuildRoleArn: '',
  componentRoleArn: '',
  description: '',
  environmentAccountConnectionId: '',
  name: '',
  protonServiceRoleArn: '',
  provisioningRepository: '',
  spec: '',
  tags: '',
  templateMajorVersion: '',
  templateMinorVersion: '',
  templateName: ''
});

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=AwsProton20200720.CreateEnvironment');
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=AwsProton20200720.CreateEnvironment',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    codebuildRoleArn: '',
    componentRoleArn: '',
    description: '',
    environmentAccountConnectionId: '',
    name: '',
    protonServiceRoleArn: '',
    provisioningRepository: '',
    spec: '',
    tags: '',
    templateMajorVersion: '',
    templateMinorVersion: '',
    templateName: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironment';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"codebuildRoleArn":"","componentRoleArn":"","description":"","environmentAccountConnectionId":"","name":"","protonServiceRoleArn":"","provisioningRepository":"","spec":"","tags":"","templateMajorVersion":"","templateMinorVersion":"","templateName":""}'
};

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=AwsProton20200720.CreateEnvironment',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "codebuildRoleArn": "",\n  "componentRoleArn": "",\n  "description": "",\n  "environmentAccountConnectionId": "",\n  "name": "",\n  "protonServiceRoleArn": "",\n  "provisioningRepository": "",\n  "spec": "",\n  "tags": "",\n  "templateMajorVersion": "",\n  "templateMinorVersion": "",\n  "templateName": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironment")
  .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({
  codebuildRoleArn: '',
  componentRoleArn: '',
  description: '',
  environmentAccountConnectionId: '',
  name: '',
  protonServiceRoleArn: '',
  provisioningRepository: '',
  spec: '',
  tags: '',
  templateMajorVersion: '',
  templateMinorVersion: '',
  templateName: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironment',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    codebuildRoleArn: '',
    componentRoleArn: '',
    description: '',
    environmentAccountConnectionId: '',
    name: '',
    protonServiceRoleArn: '',
    provisioningRepository: '',
    spec: '',
    tags: '',
    templateMajorVersion: '',
    templateMinorVersion: '',
    templateName: ''
  },
  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=AwsProton20200720.CreateEnvironment');

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

req.type('json');
req.send({
  codebuildRoleArn: '',
  componentRoleArn: '',
  description: '',
  environmentAccountConnectionId: '',
  name: '',
  protonServiceRoleArn: '',
  provisioningRepository: '',
  spec: '',
  tags: '',
  templateMajorVersion: '',
  templateMinorVersion: '',
  templateName: ''
});

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=AwsProton20200720.CreateEnvironment',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    codebuildRoleArn: '',
    componentRoleArn: '',
    description: '',
    environmentAccountConnectionId: '',
    name: '',
    protonServiceRoleArn: '',
    provisioningRepository: '',
    spec: '',
    tags: '',
    templateMajorVersion: '',
    templateMinorVersion: '',
    templateName: ''
  }
};

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=AwsProton20200720.CreateEnvironment';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"codebuildRoleArn":"","componentRoleArn":"","description":"","environmentAccountConnectionId":"","name":"","protonServiceRoleArn":"","provisioningRepository":"","spec":"","tags":"","templateMajorVersion":"","templateMinorVersion":"","templateName":""}'
};

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 = @{ @"codebuildRoleArn": @"",
                              @"componentRoleArn": @"",
                              @"description": @"",
                              @"environmentAccountConnectionId": @"",
                              @"name": @"",
                              @"protonServiceRoleArn": @"",
                              @"provisioningRepository": @"",
                              @"spec": @"",
                              @"tags": @"",
                              @"templateMajorVersion": @"",
                              @"templateMinorVersion": @"",
                              @"templateName": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironment"]
                                                       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=AwsProton20200720.CreateEnvironment" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironment",
  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([
    'codebuildRoleArn' => '',
    'componentRoleArn' => '',
    'description' => '',
    'environmentAccountConnectionId' => '',
    'name' => '',
    'protonServiceRoleArn' => '',
    'provisioningRepository' => '',
    'spec' => '',
    'tags' => '',
    'templateMajorVersion' => '',
    'templateMinorVersion' => '',
    'templateName' => ''
  ]),
  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=AwsProton20200720.CreateEnvironment', [
  'body' => '{
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "description": "",
  "environmentAccountConnectionId": "",
  "name": "",
  "protonServiceRoleArn": "",
  "provisioningRepository": "",
  "spec": "",
  "tags": "",
  "templateMajorVersion": "",
  "templateMinorVersion": "",
  "templateName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'codebuildRoleArn' => '',
  'componentRoleArn' => '',
  'description' => '',
  'environmentAccountConnectionId' => '',
  'name' => '',
  'protonServiceRoleArn' => '',
  'provisioningRepository' => '',
  'spec' => '',
  'tags' => '',
  'templateMajorVersion' => '',
  'templateMinorVersion' => '',
  'templateName' => ''
]));

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

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

append(json_encode([
  'codebuildRoleArn' => '',
  'componentRoleArn' => '',
  'description' => '',
  'environmentAccountConnectionId' => '',
  'name' => '',
  'protonServiceRoleArn' => '',
  'provisioningRepository' => '',
  'spec' => '',
  'tags' => '',
  'templateMajorVersion' => '',
  'templateMinorVersion' => '',
  'templateName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironment');
$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=AwsProton20200720.CreateEnvironment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "description": "",
  "environmentAccountConnectionId": "",
  "name": "",
  "protonServiceRoleArn": "",
  "provisioningRepository": "",
  "spec": "",
  "tags": "",
  "templateMajorVersion": "",
  "templateMinorVersion": "",
  "templateName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "description": "",
  "environmentAccountConnectionId": "",
  "name": "",
  "protonServiceRoleArn": "",
  "provisioningRepository": "",
  "spec": "",
  "tags": "",
  "templateMajorVersion": "",
  "templateMinorVersion": "",
  "templateName": ""
}'

import http.client

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

payload = "{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.CreateEnvironment"

payload = {
    "codebuildRoleArn": "",
    "componentRoleArn": "",
    "description": "",
    "environmentAccountConnectionId": "",
    "name": "",
    "protonServiceRoleArn": "",
    "provisioningRepository": "",
    "spec": "",
    "tags": "",
    "templateMajorVersion": "",
    "templateMinorVersion": "",
    "templateName": ""
}
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=AwsProton20200720.CreateEnvironment"

payload <- "{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.CreateEnvironment")

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  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\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  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.CreateEnvironment";

    let payload = json!({
        "codebuildRoleArn": "",
        "componentRoleArn": "",
        "description": "",
        "environmentAccountConnectionId": "",
        "name": "",
        "protonServiceRoleArn": "",
        "provisioningRepository": "",
        "spec": "",
        "tags": "",
        "templateMajorVersion": "",
        "templateMinorVersion": "",
        "templateName": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironment' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "description": "",
  "environmentAccountConnectionId": "",
  "name": "",
  "protonServiceRoleArn": "",
  "provisioningRepository": "",
  "spec": "",
  "tags": "",
  "templateMajorVersion": "",
  "templateMinorVersion": "",
  "templateName": ""
}'

echo '{
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "description": "",
  "environmentAccountConnectionId": "",
  "name": "",
  "protonServiceRoleArn": "",
  "provisioningRepository": "",
  "spec": "",
  "tags": "",
  "templateMajorVersion": "",
  "templateMinorVersion": "",
  "templateName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironment' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "codebuildRoleArn": "",\n  "componentRoleArn": "",\n  "description": "",\n  "environmentAccountConnectionId": "",\n  "name": "",\n  "protonServiceRoleArn": "",\n  "provisioningRepository": "",\n  "spec": "",\n  "tags": "",\n  "templateMajorVersion": "",\n  "templateMinorVersion": "",\n  "templateName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironment'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "description": "",
  "environmentAccountConnectionId": "",
  "name": "",
  "protonServiceRoleArn": "",
  "provisioningRepository": "",
  "spec": "",
  "tags": "",
  "templateMajorVersion": "",
  "templateMinorVersion": "",
  "templateName": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST CreateEnvironmentAccountConnection

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentAccountConnection

HEADERS

X-Amz-Target

BODY json

{
  "clientToken": "",
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "environmentName": "",
  "managementAccountId": "",
  "roleArn": "",
  "tags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"clientToken\": \"\",\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"environmentName\": \"\",\n  \"managementAccountId\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentAccountConnection" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:clientToken ""
                                                                                                                             :codebuildRoleArn ""
                                                                                                                             :componentRoleArn ""
                                                                                                                             :environmentName ""
                                                                                                                             :managementAccountId ""
                                                                                                                             :roleArn ""
                                                                                                                             :tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentAccountConnection"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"clientToken\": \"\",\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"environmentName\": \"\",\n  \"managementAccountId\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": \"\"\n}"

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

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

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentAccountConnection");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"clientToken\": \"\",\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"environmentName\": \"\",\n  \"managementAccountId\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentAccountConnection"

	payload := strings.NewReader("{\n  \"clientToken\": \"\",\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"environmentName\": \"\",\n  \"managementAccountId\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": \"\"\n}")

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

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

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

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

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

}

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

{
  "clientToken": "",
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "environmentName": "",
  "managementAccountId": "",
  "roleArn": "",
  "tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentAccountConnection")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"clientToken\": \"\",\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"environmentName\": \"\",\n  \"managementAccountId\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentAccountConnection"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"clientToken\": \"\",\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"environmentName\": \"\",\n  \"managementAccountId\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"clientToken\": \"\",\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"environmentName\": \"\",\n  \"managementAccountId\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentAccountConnection")
  .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=AwsProton20200720.CreateEnvironmentAccountConnection")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"clientToken\": \"\",\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"environmentName\": \"\",\n  \"managementAccountId\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  clientToken: '',
  codebuildRoleArn: '',
  componentRoleArn: '',
  environmentName: '',
  managementAccountId: '',
  roleArn: '',
  tags: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentAccountConnection');
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=AwsProton20200720.CreateEnvironmentAccountConnection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    clientToken: '',
    codebuildRoleArn: '',
    componentRoleArn: '',
    environmentName: '',
    managementAccountId: '',
    roleArn: '',
    tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentAccountConnection';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"clientToken":"","codebuildRoleArn":"","componentRoleArn":"","environmentName":"","managementAccountId":"","roleArn":"","tags":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentAccountConnection',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "clientToken": "",\n  "codebuildRoleArn": "",\n  "componentRoleArn": "",\n  "environmentName": "",\n  "managementAccountId": "",\n  "roleArn": "",\n  "tags": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"clientToken\": \"\",\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"environmentName\": \"\",\n  \"managementAccountId\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentAccountConnection")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  clientToken: '',
  codebuildRoleArn: '',
  componentRoleArn: '',
  environmentName: '',
  managementAccountId: '',
  roleArn: '',
  tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentAccountConnection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    clientToken: '',
    codebuildRoleArn: '',
    componentRoleArn: '',
    environmentName: '',
    managementAccountId: '',
    roleArn: '',
    tags: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  clientToken: '',
  codebuildRoleArn: '',
  componentRoleArn: '',
  environmentName: '',
  managementAccountId: '',
  roleArn: '',
  tags: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentAccountConnection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    clientToken: '',
    codebuildRoleArn: '',
    componentRoleArn: '',
    environmentName: '',
    managementAccountId: '',
    roleArn: '',
    tags: ''
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentAccountConnection';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"clientToken":"","codebuildRoleArn":"","componentRoleArn":"","environmentName":"","managementAccountId":"","roleArn":"","tags":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"clientToken": @"",
                              @"codebuildRoleArn": @"",
                              @"componentRoleArn": @"",
                              @"environmentName": @"",
                              @"managementAccountId": @"",
                              @"roleArn": @"",
                              @"tags": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentAccountConnection",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'clientToken' => '',
    'codebuildRoleArn' => '',
    'componentRoleArn' => '',
    'environmentName' => '',
    'managementAccountId' => '',
    'roleArn' => '',
    'tags' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentAccountConnection', [
  'body' => '{
  "clientToken": "",
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "environmentName": "",
  "managementAccountId": "",
  "roleArn": "",
  "tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'clientToken' => '',
  'codebuildRoleArn' => '',
  'componentRoleArn' => '',
  'environmentName' => '',
  'managementAccountId' => '',
  'roleArn' => '',
  'tags' => ''
]));

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

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

append(json_encode([
  'clientToken' => '',
  'codebuildRoleArn' => '',
  'componentRoleArn' => '',
  'environmentName' => '',
  'managementAccountId' => '',
  'roleArn' => '',
  'tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentAccountConnection');
$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=AwsProton20200720.CreateEnvironmentAccountConnection' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "clientToken": "",
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "environmentName": "",
  "managementAccountId": "",
  "roleArn": "",
  "tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentAccountConnection' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "clientToken": "",
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "environmentName": "",
  "managementAccountId": "",
  "roleArn": "",
  "tags": ""
}'

import http.client

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

payload = "{\n  \"clientToken\": \"\",\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"environmentName\": \"\",\n  \"managementAccountId\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentAccountConnection"

payload = {
    "clientToken": "",
    "codebuildRoleArn": "",
    "componentRoleArn": "",
    "environmentName": "",
    "managementAccountId": "",
    "roleArn": "",
    "tags": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentAccountConnection"

payload <- "{\n  \"clientToken\": \"\",\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"environmentName\": \"\",\n  \"managementAccountId\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"clientToken\": \"\",\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"environmentName\": \"\",\n  \"managementAccountId\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"clientToken\": \"\",\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"environmentName\": \"\",\n  \"managementAccountId\": \"\",\n  \"roleArn\": \"\",\n  \"tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "clientToken": "",
        "codebuildRoleArn": "",
        "componentRoleArn": "",
        "environmentName": "",
        "managementAccountId": "",
        "roleArn": "",
        "tags": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentAccountConnection' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "clientToken": "",
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "environmentName": "",
  "managementAccountId": "",
  "roleArn": "",
  "tags": ""
}'

echo '{
  "clientToken": "",
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "environmentName": "",
  "managementAccountId": "",
  "roleArn": "",
  "tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentAccountConnection' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "clientToken": "",\n  "codebuildRoleArn": "",\n  "componentRoleArn": "",\n  "environmentName": "",\n  "managementAccountId": "",\n  "roleArn": "",\n  "tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentAccountConnection'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "clientToken": "",
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "environmentName": "",
  "managementAccountId": "",
  "roleArn": "",
  "tags": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST CreateEnvironmentTemplate

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplate

HEADERS

X-Amz-Target

BODY json

{
  "description": "",
  "displayName": "",
  "encryptionKey": "",
  "name": "",
  "provisioning": "",
  "tags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"description\": \"\",\n  \"displayName\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"provisioning\": \"\",\n  \"tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplate" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:description ""
                                                                                                                    :displayName ""
                                                                                                                    :encryptionKey ""
                                                                                                                    :name ""
                                                                                                                    :provisioning ""
                                                                                                                    :tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplate"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"provisioning\": \"\",\n  \"tags\": \"\"\n}"

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

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

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplate");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"provisioning\": \"\",\n  \"tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplate"

	payload := strings.NewReader("{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"provisioning\": \"\",\n  \"tags\": \"\"\n}")

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

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

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

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

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

}

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

{
  "description": "",
  "displayName": "",
  "encryptionKey": "",
  "name": "",
  "provisioning": "",
  "tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplate")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"provisioning\": \"\",\n  \"tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"provisioning\": \"\",\n  \"tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplate")
  .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=AwsProton20200720.CreateEnvironmentTemplate")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"provisioning\": \"\",\n  \"tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  description: '',
  displayName: '',
  encryptionKey: '',
  name: '',
  provisioning: '',
  tags: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplate');
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=AwsProton20200720.CreateEnvironmentTemplate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    description: '',
    displayName: '',
    encryptionKey: '',
    name: '',
    provisioning: '',
    tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplate';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"description":"","displayName":"","encryptionKey":"","name":"","provisioning":"","tags":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplate',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "description": "",\n  "displayName": "",\n  "encryptionKey": "",\n  "name": "",\n  "provisioning": "",\n  "tags": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"provisioning\": \"\",\n  \"tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplate")
  .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({
  description: '',
  displayName: '',
  encryptionKey: '',
  name: '',
  provisioning: '',
  tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    description: '',
    displayName: '',
    encryptionKey: '',
    name: '',
    provisioning: '',
    tags: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  description: '',
  displayName: '',
  encryptionKey: '',
  name: '',
  provisioning: '',
  tags: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    description: '',
    displayName: '',
    encryptionKey: '',
    name: '',
    provisioning: '',
    tags: ''
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplate';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"description":"","displayName":"","encryptionKey":"","name":"","provisioning":"","tags":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"description": @"",
                              @"displayName": @"",
                              @"encryptionKey": @"",
                              @"name": @"",
                              @"provisioning": @"",
                              @"tags": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplate",
  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([
    'description' => '',
    'displayName' => '',
    'encryptionKey' => '',
    'name' => '',
    'provisioning' => '',
    'tags' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplate', [
  'body' => '{
  "description": "",
  "displayName": "",
  "encryptionKey": "",
  "name": "",
  "provisioning": "",
  "tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'description' => '',
  'displayName' => '',
  'encryptionKey' => '',
  'name' => '',
  'provisioning' => '',
  'tags' => ''
]));

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

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

append(json_encode([
  'description' => '',
  'displayName' => '',
  'encryptionKey' => '',
  'name' => '',
  'provisioning' => '',
  'tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplate');
$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=AwsProton20200720.CreateEnvironmentTemplate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "displayName": "",
  "encryptionKey": "",
  "name": "",
  "provisioning": "",
  "tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "displayName": "",
  "encryptionKey": "",
  "name": "",
  "provisioning": "",
  "tags": ""
}'

import http.client

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

payload = "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"provisioning\": \"\",\n  \"tags\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplate"

payload = {
    "description": "",
    "displayName": "",
    "encryptionKey": "",
    "name": "",
    "provisioning": "",
    "tags": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplate"

payload <- "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"provisioning\": \"\",\n  \"tags\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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  \"description\": \"\",\n  \"displayName\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"provisioning\": \"\",\n  \"tags\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"provisioning\": \"\",\n  \"tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "description": "",
        "displayName": "",
        "encryptionKey": "",
        "name": "",
        "provisioning": "",
        "tags": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplate' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "description": "",
  "displayName": "",
  "encryptionKey": "",
  "name": "",
  "provisioning": "",
  "tags": ""
}'

echo '{
  "description": "",
  "displayName": "",
  "encryptionKey": "",
  "name": "",
  "provisioning": "",
  "tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplate' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "description": "",\n  "displayName": "",\n  "encryptionKey": "",\n  "name": "",\n  "provisioning": "",\n  "tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplate'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "description": "",
  "displayName": "",
  "encryptionKey": "",
  "name": "",
  "provisioning": "",
  "tags": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST CreateEnvironmentTemplateVersion

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplateVersion

HEADERS

X-Amz-Target

BODY json

{
  "clientToken": "",
  "description": "",
  "majorVersion": "",
  "source": "",
  "tags": "",
  "templateName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"clientToken\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"source\": \"\",\n  \"tags\": \"\",\n  \"templateName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplateVersion" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:clientToken ""
                                                                                                                           :description ""
                                                                                                                           :majorVersion ""
                                                                                                                           :source ""
                                                                                                                           :tags ""
                                                                                                                           :templateName ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplateVersion"

	payload := strings.NewReader("{\n  \"clientToken\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"source\": \"\",\n  \"tags\": \"\",\n  \"templateName\": \"\"\n}")

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

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

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

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

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

}

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

{
  "clientToken": "",
  "description": "",
  "majorVersion": "",
  "source": "",
  "tags": "",
  "templateName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplateVersion")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"clientToken\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"source\": \"\",\n  \"tags\": \"\",\n  \"templateName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"clientToken\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"source\": \"\",\n  \"tags\": \"\",\n  \"templateName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplateVersion")
  .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=AwsProton20200720.CreateEnvironmentTemplateVersion")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"clientToken\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"source\": \"\",\n  \"tags\": \"\",\n  \"templateName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  clientToken: '',
  description: '',
  majorVersion: '',
  source: '',
  tags: '',
  templateName: ''
});

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=AwsProton20200720.CreateEnvironmentTemplateVersion');
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=AwsProton20200720.CreateEnvironmentTemplateVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    clientToken: '',
    description: '',
    majorVersion: '',
    source: '',
    tags: '',
    templateName: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplateVersion';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"clientToken":"","description":"","majorVersion":"","source":"","tags":"","templateName":""}'
};

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=AwsProton20200720.CreateEnvironmentTemplateVersion',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "clientToken": "",\n  "description": "",\n  "majorVersion": "",\n  "source": "",\n  "tags": "",\n  "templateName": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"clientToken\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"source\": \"\",\n  \"tags\": \"\",\n  \"templateName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplateVersion")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  clientToken: '',
  description: '',
  majorVersion: '',
  source: '',
  tags: '',
  templateName: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplateVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    clientToken: '',
    description: '',
    majorVersion: '',
    source: '',
    tags: '',
    templateName: ''
  },
  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=AwsProton20200720.CreateEnvironmentTemplateVersion');

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

req.type('json');
req.send({
  clientToken: '',
  description: '',
  majorVersion: '',
  source: '',
  tags: '',
  templateName: ''
});

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=AwsProton20200720.CreateEnvironmentTemplateVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    clientToken: '',
    description: '',
    majorVersion: '',
    source: '',
    tags: '',
    templateName: ''
  }
};

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=AwsProton20200720.CreateEnvironmentTemplateVersion';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"clientToken":"","description":"","majorVersion":"","source":"","tags":"","templateName":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"clientToken": @"",
                              @"description": @"",
                              @"majorVersion": @"",
                              @"source": @"",
                              @"tags": @"",
                              @"templateName": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplateVersion",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'clientToken' => '',
    'description' => '',
    'majorVersion' => '',
    'source' => '',
    'tags' => '',
    'templateName' => ''
  ]),
  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=AwsProton20200720.CreateEnvironmentTemplateVersion', [
  'body' => '{
  "clientToken": "",
  "description": "",
  "majorVersion": "",
  "source": "",
  "tags": "",
  "templateName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'clientToken' => '',
  'description' => '',
  'majorVersion' => '',
  'source' => '',
  'tags' => '',
  'templateName' => ''
]));

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

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

append(json_encode([
  'clientToken' => '',
  'description' => '',
  'majorVersion' => '',
  'source' => '',
  'tags' => '',
  'templateName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplateVersion');
$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=AwsProton20200720.CreateEnvironmentTemplateVersion' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "clientToken": "",
  "description": "",
  "majorVersion": "",
  "source": "",
  "tags": "",
  "templateName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplateVersion' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "clientToken": "",
  "description": "",
  "majorVersion": "",
  "source": "",
  "tags": "",
  "templateName": ""
}'

import http.client

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

payload = "{\n  \"clientToken\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"source\": \"\",\n  \"tags\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.CreateEnvironmentTemplateVersion"

payload = {
    "clientToken": "",
    "description": "",
    "majorVersion": "",
    "source": "",
    "tags": "",
    "templateName": ""
}
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=AwsProton20200720.CreateEnvironmentTemplateVersion"

payload <- "{\n  \"clientToken\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"source\": \"\",\n  \"tags\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.CreateEnvironmentTemplateVersion")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"clientToken\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"source\": \"\",\n  \"tags\": \"\",\n  \"templateName\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"clientToken\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"source\": \"\",\n  \"tags\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.CreateEnvironmentTemplateVersion";

    let payload = json!({
        "clientToken": "",
        "description": "",
        "majorVersion": "",
        "source": "",
        "tags": "",
        "templateName": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplateVersion' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "clientToken": "",
  "description": "",
  "majorVersion": "",
  "source": "",
  "tags": "",
  "templateName": ""
}'

echo '{
  "clientToken": "",
  "description": "",
  "majorVersion": "",
  "source": "",
  "tags": "",
  "templateName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplateVersion' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "clientToken": "",\n  "description": "",\n  "majorVersion": "",\n  "source": "",\n  "tags": "",\n  "templateName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateEnvironmentTemplateVersion'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "clientToken": "",
  "description": "",
  "majorVersion": "",
  "source": "",
  "tags": "",
  "templateName": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST CreateRepository

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateRepository

HEADERS

X-Amz-Target

BODY json

{
  "connectionArn": "",
  "encryptionKey": "",
  "name": "",
  "provider": "",
  "tags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"connectionArn\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"provider\": \"\",\n  \"tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateRepository" {:headers {:x-amz-target ""}
                                                                                             :content-type :json
                                                                                             :form-params {:connectionArn ""
                                                                                                           :encryptionKey ""
                                                                                                           :name ""
                                                                                                           :provider ""
                                                                                                           :tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateRepository"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"connectionArn\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"provider\": \"\",\n  \"tags\": \"\"\n}"

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

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

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateRepository");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"connectionArn\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"provider\": \"\",\n  \"tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateRepository"

	payload := strings.NewReader("{\n  \"connectionArn\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"provider\": \"\",\n  \"tags\": \"\"\n}")

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

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

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

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

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

}

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

{
  "connectionArn": "",
  "encryptionKey": "",
  "name": "",
  "provider": "",
  "tags": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"connectionArn\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"provider\": \"\",\n  \"tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateRepository")
  .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=AwsProton20200720.CreateRepository")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"connectionArn\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"provider\": \"\",\n  \"tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  connectionArn: '',
  encryptionKey: '',
  name: '',
  provider: '',
  tags: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateRepository');
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=AwsProton20200720.CreateRepository',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {connectionArn: '', encryptionKey: '', name: '', provider: '', tags: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateRepository';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"connectionArn":"","encryptionKey":"","name":"","provider":"","tags":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateRepository',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "connectionArn": "",\n  "encryptionKey": "",\n  "name": "",\n  "provider": "",\n  "tags": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateRepository',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {connectionArn: '', encryptionKey: '', name: '', provider: '', tags: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  connectionArn: '',
  encryptionKey: '',
  name: '',
  provider: '',
  tags: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateRepository',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {connectionArn: '', encryptionKey: '', name: '', provider: '', tags: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateRepository';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"connectionArn":"","encryptionKey":"","name":"","provider":"","tags":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"connectionArn": @"",
                              @"encryptionKey": @"",
                              @"name": @"",
                              @"provider": @"",
                              @"tags": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateRepository",
  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([
    'connectionArn' => '',
    'encryptionKey' => '',
    'name' => '',
    'provider' => '',
    'tags' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateRepository', [
  'body' => '{
  "connectionArn": "",
  "encryptionKey": "",
  "name": "",
  "provider": "",
  "tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'connectionArn' => '',
  'encryptionKey' => '',
  'name' => '',
  'provider' => '',
  'tags' => ''
]));

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

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

append(json_encode([
  'connectionArn' => '',
  'encryptionKey' => '',
  'name' => '',
  'provider' => '',
  'tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateRepository');
$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=AwsProton20200720.CreateRepository' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "connectionArn": "",
  "encryptionKey": "",
  "name": "",
  "provider": "",
  "tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateRepository' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "connectionArn": "",
  "encryptionKey": "",
  "name": "",
  "provider": "",
  "tags": ""
}'

import http.client

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

payload = "{\n  \"connectionArn\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"provider\": \"\",\n  \"tags\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateRepository"

payload = {
    "connectionArn": "",
    "encryptionKey": "",
    "name": "",
    "provider": "",
    "tags": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateRepository"

payload <- "{\n  \"connectionArn\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"provider\": \"\",\n  \"tags\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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  \"connectionArn\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"provider\": \"\",\n  \"tags\": \"\"\n}"

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "connectionArn": "",
        "encryptionKey": "",
        "name": "",
        "provider": "",
        "tags": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateRepository' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "connectionArn": "",
  "encryptionKey": "",
  "name": "",
  "provider": "",
  "tags": ""
}'

echo '{
  "connectionArn": "",
  "encryptionKey": "",
  "name": "",
  "provider": "",
  "tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateRepository' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "connectionArn": "",\n  "encryptionKey": "",\n  "name": "",\n  "provider": "",\n  "tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateRepository'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "connectionArn": "",
  "encryptionKey": "",
  "name": "",
  "provider": "",
  "tags": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST CreateService

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateService

HEADERS

X-Amz-Target

BODY json

{
  "branchName": "",
  "description": "",
  "name": "",
  "repositoryConnectionArn": "",
  "repositoryId": "",
  "spec": "",
  "tags": "",
  "templateMajorVersion": "",
  "templateMinorVersion": "",
  "templateName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"branchName\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"repositoryConnectionArn\": \"\",\n  \"repositoryId\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateService" {:headers {:x-amz-target ""}
                                                                                          :content-type :json
                                                                                          :form-params {:branchName ""
                                                                                                        :description ""
                                                                                                        :name ""
                                                                                                        :repositoryConnectionArn ""
                                                                                                        :repositoryId ""
                                                                                                        :spec ""
                                                                                                        :tags ""
                                                                                                        :templateMajorVersion ""
                                                                                                        :templateMinorVersion ""
                                                                                                        :templateName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateService"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"branchName\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"repositoryConnectionArn\": \"\",\n  \"repositoryId\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.CreateService"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"branchName\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"repositoryConnectionArn\": \"\",\n  \"repositoryId\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.CreateService");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"branchName\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"repositoryConnectionArn\": \"\",\n  \"repositoryId\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateService"

	payload := strings.NewReader("{\n  \"branchName\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"repositoryConnectionArn\": \"\",\n  \"repositoryId\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\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: 222

{
  "branchName": "",
  "description": "",
  "name": "",
  "repositoryConnectionArn": "",
  "repositoryId": "",
  "spec": "",
  "tags": "",
  "templateMajorVersion": "",
  "templateMinorVersion": "",
  "templateName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateService")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"branchName\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"repositoryConnectionArn\": \"\",\n  \"repositoryId\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateService"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"branchName\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"repositoryConnectionArn\": \"\",\n  \"repositoryId\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\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  \"branchName\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"repositoryConnectionArn\": \"\",\n  \"repositoryId\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateService")
  .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=AwsProton20200720.CreateService")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"branchName\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"repositoryConnectionArn\": \"\",\n  \"repositoryId\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  branchName: '',
  description: '',
  name: '',
  repositoryConnectionArn: '',
  repositoryId: '',
  spec: '',
  tags: '',
  templateMajorVersion: '',
  templateMinorVersion: '',
  templateName: ''
});

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=AwsProton20200720.CreateService');
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=AwsProton20200720.CreateService',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    branchName: '',
    description: '',
    name: '',
    repositoryConnectionArn: '',
    repositoryId: '',
    spec: '',
    tags: '',
    templateMajorVersion: '',
    templateMinorVersion: '',
    templateName: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateService';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"branchName":"","description":"","name":"","repositoryConnectionArn":"","repositoryId":"","spec":"","tags":"","templateMajorVersion":"","templateMinorVersion":"","templateName":""}'
};

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=AwsProton20200720.CreateService',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "branchName": "",\n  "description": "",\n  "name": "",\n  "repositoryConnectionArn": "",\n  "repositoryId": "",\n  "spec": "",\n  "tags": "",\n  "templateMajorVersion": "",\n  "templateMinorVersion": "",\n  "templateName": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"branchName\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"repositoryConnectionArn\": \"\",\n  \"repositoryId\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateService")
  .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({
  branchName: '',
  description: '',
  name: '',
  repositoryConnectionArn: '',
  repositoryId: '',
  spec: '',
  tags: '',
  templateMajorVersion: '',
  templateMinorVersion: '',
  templateName: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateService',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    branchName: '',
    description: '',
    name: '',
    repositoryConnectionArn: '',
    repositoryId: '',
    spec: '',
    tags: '',
    templateMajorVersion: '',
    templateMinorVersion: '',
    templateName: ''
  },
  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=AwsProton20200720.CreateService');

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

req.type('json');
req.send({
  branchName: '',
  description: '',
  name: '',
  repositoryConnectionArn: '',
  repositoryId: '',
  spec: '',
  tags: '',
  templateMajorVersion: '',
  templateMinorVersion: '',
  templateName: ''
});

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=AwsProton20200720.CreateService',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    branchName: '',
    description: '',
    name: '',
    repositoryConnectionArn: '',
    repositoryId: '',
    spec: '',
    tags: '',
    templateMajorVersion: '',
    templateMinorVersion: '',
    templateName: ''
  }
};

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=AwsProton20200720.CreateService';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"branchName":"","description":"","name":"","repositoryConnectionArn":"","repositoryId":"","spec":"","tags":"","templateMajorVersion":"","templateMinorVersion":"","templateName":""}'
};

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 = @{ @"branchName": @"",
                              @"description": @"",
                              @"name": @"",
                              @"repositoryConnectionArn": @"",
                              @"repositoryId": @"",
                              @"spec": @"",
                              @"tags": @"",
                              @"templateMajorVersion": @"",
                              @"templateMinorVersion": @"",
                              @"templateName": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateService"]
                                                       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=AwsProton20200720.CreateService" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"branchName\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"repositoryConnectionArn\": \"\",\n  \"repositoryId\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateService",
  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([
    'branchName' => '',
    'description' => '',
    'name' => '',
    'repositoryConnectionArn' => '',
    'repositoryId' => '',
    'spec' => '',
    'tags' => '',
    'templateMajorVersion' => '',
    'templateMinorVersion' => '',
    'templateName' => ''
  ]),
  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=AwsProton20200720.CreateService', [
  'body' => '{
  "branchName": "",
  "description": "",
  "name": "",
  "repositoryConnectionArn": "",
  "repositoryId": "",
  "spec": "",
  "tags": "",
  "templateMajorVersion": "",
  "templateMinorVersion": "",
  "templateName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'branchName' => '',
  'description' => '',
  'name' => '',
  'repositoryConnectionArn' => '',
  'repositoryId' => '',
  'spec' => '',
  'tags' => '',
  'templateMajorVersion' => '',
  'templateMinorVersion' => '',
  'templateName' => ''
]));

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

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

append(json_encode([
  'branchName' => '',
  'description' => '',
  'name' => '',
  'repositoryConnectionArn' => '',
  'repositoryId' => '',
  'spec' => '',
  'tags' => '',
  'templateMajorVersion' => '',
  'templateMinorVersion' => '',
  'templateName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateService');
$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=AwsProton20200720.CreateService' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "branchName": "",
  "description": "",
  "name": "",
  "repositoryConnectionArn": "",
  "repositoryId": "",
  "spec": "",
  "tags": "",
  "templateMajorVersion": "",
  "templateMinorVersion": "",
  "templateName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateService' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "branchName": "",
  "description": "",
  "name": "",
  "repositoryConnectionArn": "",
  "repositoryId": "",
  "spec": "",
  "tags": "",
  "templateMajorVersion": "",
  "templateMinorVersion": "",
  "templateName": ""
}'

import http.client

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

payload = "{\n  \"branchName\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"repositoryConnectionArn\": \"\",\n  \"repositoryId\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.CreateService"

payload = {
    "branchName": "",
    "description": "",
    "name": "",
    "repositoryConnectionArn": "",
    "repositoryId": "",
    "spec": "",
    "tags": "",
    "templateMajorVersion": "",
    "templateMinorVersion": "",
    "templateName": ""
}
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=AwsProton20200720.CreateService"

payload <- "{\n  \"branchName\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"repositoryConnectionArn\": \"\",\n  \"repositoryId\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.CreateService")

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  \"branchName\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"repositoryConnectionArn\": \"\",\n  \"repositoryId\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\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  \"branchName\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"repositoryConnectionArn\": \"\",\n  \"repositoryId\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.CreateService";

    let payload = json!({
        "branchName": "",
        "description": "",
        "name": "",
        "repositoryConnectionArn": "",
        "repositoryId": "",
        "spec": "",
        "tags": "",
        "templateMajorVersion": "",
        "templateMinorVersion": "",
        "templateName": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateService' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "branchName": "",
  "description": "",
  "name": "",
  "repositoryConnectionArn": "",
  "repositoryId": "",
  "spec": "",
  "tags": "",
  "templateMajorVersion": "",
  "templateMinorVersion": "",
  "templateName": ""
}'

echo '{
  "branchName": "",
  "description": "",
  "name": "",
  "repositoryConnectionArn": "",
  "repositoryId": "",
  "spec": "",
  "tags": "",
  "templateMajorVersion": "",
  "templateMinorVersion": "",
  "templateName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateService' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "branchName": "",\n  "description": "",\n  "name": "",\n  "repositoryConnectionArn": "",\n  "repositoryId": "",\n  "spec": "",\n  "tags": "",\n  "templateMajorVersion": "",\n  "templateMinorVersion": "",\n  "templateName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateService'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "branchName": "",
  "description": "",
  "name": "",
  "repositoryConnectionArn": "",
  "repositoryId": "",
  "spec": "",
  "tags": "",
  "templateMajorVersion": "",
  "templateMinorVersion": "",
  "templateName": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST CreateServiceInstance

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceInstance

HEADERS

X-Amz-Target

BODY json

{
  "clientToken": "",
  "name": "",
  "serviceName": "",
  "spec": "",
  "tags": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"clientToken\": \"\",\n  \"name\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceInstance" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:clientToken ""
                                                                                                                :name ""
                                                                                                                :serviceName ""
                                                                                                                :spec ""
                                                                                                                :tags ""
                                                                                                                :templateMajorVersion ""
                                                                                                                :templateMinorVersion ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceInstance"

	payload := strings.NewReader("{\n  \"clientToken\": \"\",\n  \"name\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}")

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

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

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

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

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

}

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

{
  "clientToken": "",
  "name": "",
  "serviceName": "",
  "spec": "",
  "tags": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceInstance")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"clientToken\": \"\",\n  \"name\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceInstance"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"clientToken\": \"\",\n  \"name\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"clientToken\": \"\",\n  \"name\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceInstance")
  .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=AwsProton20200720.CreateServiceInstance")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"clientToken\": \"\",\n  \"name\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  clientToken: '',
  name: '',
  serviceName: '',
  spec: '',
  tags: '',
  templateMajorVersion: '',
  templateMinorVersion: ''
});

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=AwsProton20200720.CreateServiceInstance');
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=AwsProton20200720.CreateServiceInstance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    clientToken: '',
    name: '',
    serviceName: '',
    spec: '',
    tags: '',
    templateMajorVersion: '',
    templateMinorVersion: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceInstance';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"clientToken":"","name":"","serviceName":"","spec":"","tags":"","templateMajorVersion":"","templateMinorVersion":""}'
};

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=AwsProton20200720.CreateServiceInstance',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "clientToken": "",\n  "name": "",\n  "serviceName": "",\n  "spec": "",\n  "tags": "",\n  "templateMajorVersion": "",\n  "templateMinorVersion": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"clientToken\": \"\",\n  \"name\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceInstance")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  clientToken: '',
  name: '',
  serviceName: '',
  spec: '',
  tags: '',
  templateMajorVersion: '',
  templateMinorVersion: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceInstance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    clientToken: '',
    name: '',
    serviceName: '',
    spec: '',
    tags: '',
    templateMajorVersion: '',
    templateMinorVersion: ''
  },
  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=AwsProton20200720.CreateServiceInstance');

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

req.type('json');
req.send({
  clientToken: '',
  name: '',
  serviceName: '',
  spec: '',
  tags: '',
  templateMajorVersion: '',
  templateMinorVersion: ''
});

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=AwsProton20200720.CreateServiceInstance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    clientToken: '',
    name: '',
    serviceName: '',
    spec: '',
    tags: '',
    templateMajorVersion: '',
    templateMinorVersion: ''
  }
};

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=AwsProton20200720.CreateServiceInstance';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"clientToken":"","name":"","serviceName":"","spec":"","tags":"","templateMajorVersion":"","templateMinorVersion":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"clientToken": @"",
                              @"name": @"",
                              @"serviceName": @"",
                              @"spec": @"",
                              @"tags": @"",
                              @"templateMajorVersion": @"",
                              @"templateMinorVersion": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceInstance",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'clientToken' => '',
    'name' => '',
    'serviceName' => '',
    'spec' => '',
    'tags' => '',
    'templateMajorVersion' => '',
    'templateMinorVersion' => ''
  ]),
  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=AwsProton20200720.CreateServiceInstance', [
  'body' => '{
  "clientToken": "",
  "name": "",
  "serviceName": "",
  "spec": "",
  "tags": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'clientToken' => '',
  'name' => '',
  'serviceName' => '',
  'spec' => '',
  'tags' => '',
  'templateMajorVersion' => '',
  'templateMinorVersion' => ''
]));

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

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

append(json_encode([
  'clientToken' => '',
  'name' => '',
  'serviceName' => '',
  'spec' => '',
  'tags' => '',
  'templateMajorVersion' => '',
  'templateMinorVersion' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceInstance');
$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=AwsProton20200720.CreateServiceInstance' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "clientToken": "",
  "name": "",
  "serviceName": "",
  "spec": "",
  "tags": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceInstance' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "clientToken": "",
  "name": "",
  "serviceName": "",
  "spec": "",
  "tags": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}'

import http.client

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

payload = "{\n  \"clientToken\": \"\",\n  \"name\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\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=AwsProton20200720.CreateServiceInstance"

payload = {
    "clientToken": "",
    "name": "",
    "serviceName": "",
    "spec": "",
    "tags": "",
    "templateMajorVersion": "",
    "templateMinorVersion": ""
}
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=AwsProton20200720.CreateServiceInstance"

payload <- "{\n  \"clientToken\": \"\",\n  \"name\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\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=AwsProton20200720.CreateServiceInstance")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"clientToken\": \"\",\n  \"name\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"clientToken\": \"\",\n  \"name\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"tags\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\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=AwsProton20200720.CreateServiceInstance";

    let payload = json!({
        "clientToken": "",
        "name": "",
        "serviceName": "",
        "spec": "",
        "tags": "",
        "templateMajorVersion": "",
        "templateMinorVersion": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceInstance' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "clientToken": "",
  "name": "",
  "serviceName": "",
  "spec": "",
  "tags": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}'

echo '{
  "clientToken": "",
  "name": "",
  "serviceName": "",
  "spec": "",
  "tags": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceInstance' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "clientToken": "",\n  "name": "",\n  "serviceName": "",\n  "spec": "",\n  "tags": "",\n  "templateMajorVersion": "",\n  "templateMinorVersion": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceInstance'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "clientToken": "",
  "name": "",
  "serviceName": "",
  "spec": "",
  "tags": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST CreateServiceSyncConfig

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceSyncConfig

HEADERS

X-Amz-Target

BODY json

{
  "branch": "",
  "filePath": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "serviceName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"branch\": \"\",\n  \"filePath\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"serviceName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceSyncConfig" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:branch ""
                                                                                                                  :filePath ""
                                                                                                                  :repositoryName ""
                                                                                                                  :repositoryProvider ""
                                                                                                                  :serviceName ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceSyncConfig"

	payload := strings.NewReader("{\n  \"branch\": \"\",\n  \"filePath\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"serviceName\": \"\"\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: 109

{
  "branch": "",
  "filePath": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "serviceName": ""
}

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

client.close();

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

const data = JSON.stringify({
  branch: '',
  filePath: '',
  repositoryName: '',
  repositoryProvider: '',
  serviceName: ''
});

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=AwsProton20200720.CreateServiceSyncConfig');
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=AwsProton20200720.CreateServiceSyncConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    branch: '',
    filePath: '',
    repositoryName: '',
    repositoryProvider: '',
    serviceName: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceSyncConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"branch":"","filePath":"","repositoryName":"","repositoryProvider":"","serviceName":""}'
};

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=AwsProton20200720.CreateServiceSyncConfig',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "branch": "",\n  "filePath": "",\n  "repositoryName": "",\n  "repositoryProvider": "",\n  "serviceName": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceSyncConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    branch: '',
    filePath: '',
    repositoryName: '',
    repositoryProvider: '',
    serviceName: ''
  },
  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=AwsProton20200720.CreateServiceSyncConfig');

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

req.type('json');
req.send({
  branch: '',
  filePath: '',
  repositoryName: '',
  repositoryProvider: '',
  serviceName: ''
});

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=AwsProton20200720.CreateServiceSyncConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    branch: '',
    filePath: '',
    repositoryName: '',
    repositoryProvider: '',
    serviceName: ''
  }
};

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=AwsProton20200720.CreateServiceSyncConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"branch":"","filePath":"","repositoryName":"","repositoryProvider":"","serviceName":""}'
};

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 = @{ @"branch": @"",
                              @"filePath": @"",
                              @"repositoryName": @"",
                              @"repositoryProvider": @"",
                              @"serviceName": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceSyncConfig",
  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([
    'branch' => '',
    'filePath' => '',
    'repositoryName' => '',
    'repositoryProvider' => '',
    'serviceName' => ''
  ]),
  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=AwsProton20200720.CreateServiceSyncConfig', [
  'body' => '{
  "branch": "",
  "filePath": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "serviceName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'branch' => '',
  'filePath' => '',
  'repositoryName' => '',
  'repositoryProvider' => '',
  'serviceName' => ''
]));

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

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

append(json_encode([
  'branch' => '',
  'filePath' => '',
  'repositoryName' => '',
  'repositoryProvider' => '',
  'serviceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceSyncConfig');
$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=AwsProton20200720.CreateServiceSyncConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "branch": "",
  "filePath": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "serviceName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceSyncConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "branch": "",
  "filePath": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "serviceName": ""
}'

import http.client

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

payload = "{\n  \"branch\": \"\",\n  \"filePath\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.CreateServiceSyncConfig"

payload = {
    "branch": "",
    "filePath": "",
    "repositoryName": "",
    "repositoryProvider": "",
    "serviceName": ""
}
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=AwsProton20200720.CreateServiceSyncConfig"

payload <- "{\n  \"branch\": \"\",\n  \"filePath\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.CreateServiceSyncConfig")

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  \"branch\": \"\",\n  \"filePath\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"serviceName\": \"\"\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  \"branch\": \"\",\n  \"filePath\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.CreateServiceSyncConfig";

    let payload = json!({
        "branch": "",
        "filePath": "",
        "repositoryName": "",
        "repositoryProvider": "",
        "serviceName": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceSyncConfig' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "branch": "",
  "filePath": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "serviceName": ""
}'

echo '{
  "branch": "",
  "filePath": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "serviceName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceSyncConfig' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "branch": "",\n  "filePath": "",\n  "repositoryName": "",\n  "repositoryProvider": "",\n  "serviceName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceSyncConfig'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "branch": "",
  "filePath": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "serviceName": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST CreateServiceTemplate

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplate

HEADERS

X-Amz-Target

BODY json

{
  "description": "",
  "displayName": "",
  "encryptionKey": "",
  "name": "",
  "pipelineProvisioning": "",
  "tags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"description\": \"\",\n  \"displayName\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"pipelineProvisioning\": \"\",\n  \"tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplate" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:description ""
                                                                                                                :displayName ""
                                                                                                                :encryptionKey ""
                                                                                                                :name ""
                                                                                                                :pipelineProvisioning ""
                                                                                                                :tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplate"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"pipelineProvisioning\": \"\",\n  \"tags\": \"\"\n}"

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

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

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplate");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"pipelineProvisioning\": \"\",\n  \"tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplate"

	payload := strings.NewReader("{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"pipelineProvisioning\": \"\",\n  \"tags\": \"\"\n}")

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

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

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

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

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

}

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

{
  "description": "",
  "displayName": "",
  "encryptionKey": "",
  "name": "",
  "pipelineProvisioning": "",
  "tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplate")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"pipelineProvisioning\": \"\",\n  \"tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"pipelineProvisioning\": \"\",\n  \"tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplate")
  .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=AwsProton20200720.CreateServiceTemplate")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"pipelineProvisioning\": \"\",\n  \"tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  description: '',
  displayName: '',
  encryptionKey: '',
  name: '',
  pipelineProvisioning: '',
  tags: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplate');
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=AwsProton20200720.CreateServiceTemplate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    description: '',
    displayName: '',
    encryptionKey: '',
    name: '',
    pipelineProvisioning: '',
    tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplate';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"description":"","displayName":"","encryptionKey":"","name":"","pipelineProvisioning":"","tags":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplate',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "description": "",\n  "displayName": "",\n  "encryptionKey": "",\n  "name": "",\n  "pipelineProvisioning": "",\n  "tags": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"pipelineProvisioning\": \"\",\n  \"tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplate")
  .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({
  description: '',
  displayName: '',
  encryptionKey: '',
  name: '',
  pipelineProvisioning: '',
  tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    description: '',
    displayName: '',
    encryptionKey: '',
    name: '',
    pipelineProvisioning: '',
    tags: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  description: '',
  displayName: '',
  encryptionKey: '',
  name: '',
  pipelineProvisioning: '',
  tags: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    description: '',
    displayName: '',
    encryptionKey: '',
    name: '',
    pipelineProvisioning: '',
    tags: ''
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplate';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"description":"","displayName":"","encryptionKey":"","name":"","pipelineProvisioning":"","tags":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"description": @"",
                              @"displayName": @"",
                              @"encryptionKey": @"",
                              @"name": @"",
                              @"pipelineProvisioning": @"",
                              @"tags": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplate",
  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([
    'description' => '',
    'displayName' => '',
    'encryptionKey' => '',
    'name' => '',
    'pipelineProvisioning' => '',
    'tags' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplate', [
  'body' => '{
  "description": "",
  "displayName": "",
  "encryptionKey": "",
  "name": "",
  "pipelineProvisioning": "",
  "tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'description' => '',
  'displayName' => '',
  'encryptionKey' => '',
  'name' => '',
  'pipelineProvisioning' => '',
  'tags' => ''
]));

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

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

append(json_encode([
  'description' => '',
  'displayName' => '',
  'encryptionKey' => '',
  'name' => '',
  'pipelineProvisioning' => '',
  'tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplate');
$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=AwsProton20200720.CreateServiceTemplate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "displayName": "",
  "encryptionKey": "",
  "name": "",
  "pipelineProvisioning": "",
  "tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "displayName": "",
  "encryptionKey": "",
  "name": "",
  "pipelineProvisioning": "",
  "tags": ""
}'

import http.client

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

payload = "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"pipelineProvisioning\": \"\",\n  \"tags\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplate"

payload = {
    "description": "",
    "displayName": "",
    "encryptionKey": "",
    "name": "",
    "pipelineProvisioning": "",
    "tags": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplate"

payload <- "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"pipelineProvisioning\": \"\",\n  \"tags\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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  \"description\": \"\",\n  \"displayName\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"pipelineProvisioning\": \"\",\n  \"tags\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"encryptionKey\": \"\",\n  \"name\": \"\",\n  \"pipelineProvisioning\": \"\",\n  \"tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "description": "",
        "displayName": "",
        "encryptionKey": "",
        "name": "",
        "pipelineProvisioning": "",
        "tags": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplate' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "description": "",
  "displayName": "",
  "encryptionKey": "",
  "name": "",
  "pipelineProvisioning": "",
  "tags": ""
}'

echo '{
  "description": "",
  "displayName": "",
  "encryptionKey": "",
  "name": "",
  "pipelineProvisioning": "",
  "tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplate' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "description": "",\n  "displayName": "",\n  "encryptionKey": "",\n  "name": "",\n  "pipelineProvisioning": "",\n  "tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplate'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "description": "",
  "displayName": "",
  "encryptionKey": "",
  "name": "",
  "pipelineProvisioning": "",
  "tags": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST CreateServiceTemplateVersion

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplateVersion

HEADERS

X-Amz-Target

BODY json

{
  "clientToken": "",
  "compatibleEnvironmentTemplates": "",
  "description": "",
  "majorVersion": "",
  "source": "",
  "supportedComponentSources": "",
  "tags": "",
  "templateName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"clientToken\": \"\",\n  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"source\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"tags\": \"\",\n  \"templateName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplateVersion" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:clientToken ""
                                                                                                                       :compatibleEnvironmentTemplates ""
                                                                                                                       :description ""
                                                                                                                       :majorVersion ""
                                                                                                                       :source ""
                                                                                                                       :supportedComponentSources ""
                                                                                                                       :tags ""
                                                                                                                       :templateName ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplateVersion"

	payload := strings.NewReader("{\n  \"clientToken\": \"\",\n  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"source\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"tags\": \"\",\n  \"templateName\": \"\"\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: 193

{
  "clientToken": "",
  "compatibleEnvironmentTemplates": "",
  "description": "",
  "majorVersion": "",
  "source": "",
  "supportedComponentSources": "",
  "tags": "",
  "templateName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplateVersion")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"clientToken\": \"\",\n  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"source\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"tags\": \"\",\n  \"templateName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplateVersion"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"clientToken\": \"\",\n  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"source\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"tags\": \"\",\n  \"templateName\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"clientToken\": \"\",\n  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"source\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"tags\": \"\",\n  \"templateName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplateVersion")
  .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=AwsProton20200720.CreateServiceTemplateVersion")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"clientToken\": \"\",\n  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"source\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"tags\": \"\",\n  \"templateName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  clientToken: '',
  compatibleEnvironmentTemplates: '',
  description: '',
  majorVersion: '',
  source: '',
  supportedComponentSources: '',
  tags: '',
  templateName: ''
});

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=AwsProton20200720.CreateServiceTemplateVersion');
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=AwsProton20200720.CreateServiceTemplateVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    clientToken: '',
    compatibleEnvironmentTemplates: '',
    description: '',
    majorVersion: '',
    source: '',
    supportedComponentSources: '',
    tags: '',
    templateName: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplateVersion';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"clientToken":"","compatibleEnvironmentTemplates":"","description":"","majorVersion":"","source":"","supportedComponentSources":"","tags":"","templateName":""}'
};

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=AwsProton20200720.CreateServiceTemplateVersion',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "clientToken": "",\n  "compatibleEnvironmentTemplates": "",\n  "description": "",\n  "majorVersion": "",\n  "source": "",\n  "supportedComponentSources": "",\n  "tags": "",\n  "templateName": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"clientToken\": \"\",\n  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"source\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"tags\": \"\",\n  \"templateName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplateVersion")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  clientToken: '',
  compatibleEnvironmentTemplates: '',
  description: '',
  majorVersion: '',
  source: '',
  supportedComponentSources: '',
  tags: '',
  templateName: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplateVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    clientToken: '',
    compatibleEnvironmentTemplates: '',
    description: '',
    majorVersion: '',
    source: '',
    supportedComponentSources: '',
    tags: '',
    templateName: ''
  },
  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=AwsProton20200720.CreateServiceTemplateVersion');

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

req.type('json');
req.send({
  clientToken: '',
  compatibleEnvironmentTemplates: '',
  description: '',
  majorVersion: '',
  source: '',
  supportedComponentSources: '',
  tags: '',
  templateName: ''
});

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=AwsProton20200720.CreateServiceTemplateVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    clientToken: '',
    compatibleEnvironmentTemplates: '',
    description: '',
    majorVersion: '',
    source: '',
    supportedComponentSources: '',
    tags: '',
    templateName: ''
  }
};

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=AwsProton20200720.CreateServiceTemplateVersion';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"clientToken":"","compatibleEnvironmentTemplates":"","description":"","majorVersion":"","source":"","supportedComponentSources":"","tags":"","templateName":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"clientToken": @"",
                              @"compatibleEnvironmentTemplates": @"",
                              @"description": @"",
                              @"majorVersion": @"",
                              @"source": @"",
                              @"supportedComponentSources": @"",
                              @"tags": @"",
                              @"templateName": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplateVersion"]
                                                       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=AwsProton20200720.CreateServiceTemplateVersion" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"clientToken\": \"\",\n  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"source\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"tags\": \"\",\n  \"templateName\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplateVersion",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'clientToken' => '',
    'compatibleEnvironmentTemplates' => '',
    'description' => '',
    'majorVersion' => '',
    'source' => '',
    'supportedComponentSources' => '',
    'tags' => '',
    'templateName' => ''
  ]),
  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=AwsProton20200720.CreateServiceTemplateVersion', [
  'body' => '{
  "clientToken": "",
  "compatibleEnvironmentTemplates": "",
  "description": "",
  "majorVersion": "",
  "source": "",
  "supportedComponentSources": "",
  "tags": "",
  "templateName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'clientToken' => '',
  'compatibleEnvironmentTemplates' => '',
  'description' => '',
  'majorVersion' => '',
  'source' => '',
  'supportedComponentSources' => '',
  'tags' => '',
  'templateName' => ''
]));

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

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

append(json_encode([
  'clientToken' => '',
  'compatibleEnvironmentTemplates' => '',
  'description' => '',
  'majorVersion' => '',
  'source' => '',
  'supportedComponentSources' => '',
  'tags' => '',
  'templateName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplateVersion');
$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=AwsProton20200720.CreateServiceTemplateVersion' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "clientToken": "",
  "compatibleEnvironmentTemplates": "",
  "description": "",
  "majorVersion": "",
  "source": "",
  "supportedComponentSources": "",
  "tags": "",
  "templateName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplateVersion' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "clientToken": "",
  "compatibleEnvironmentTemplates": "",
  "description": "",
  "majorVersion": "",
  "source": "",
  "supportedComponentSources": "",
  "tags": "",
  "templateName": ""
}'

import http.client

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

payload = "{\n  \"clientToken\": \"\",\n  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"source\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"tags\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.CreateServiceTemplateVersion"

payload = {
    "clientToken": "",
    "compatibleEnvironmentTemplates": "",
    "description": "",
    "majorVersion": "",
    "source": "",
    "supportedComponentSources": "",
    "tags": "",
    "templateName": ""
}
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=AwsProton20200720.CreateServiceTemplateVersion"

payload <- "{\n  \"clientToken\": \"\",\n  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"source\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"tags\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.CreateServiceTemplateVersion")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"clientToken\": \"\",\n  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"source\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"tags\": \"\",\n  \"templateName\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"clientToken\": \"\",\n  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"source\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"tags\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.CreateServiceTemplateVersion";

    let payload = json!({
        "clientToken": "",
        "compatibleEnvironmentTemplates": "",
        "description": "",
        "majorVersion": "",
        "source": "",
        "supportedComponentSources": "",
        "tags": "",
        "templateName": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplateVersion' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "clientToken": "",
  "compatibleEnvironmentTemplates": "",
  "description": "",
  "majorVersion": "",
  "source": "",
  "supportedComponentSources": "",
  "tags": "",
  "templateName": ""
}'

echo '{
  "clientToken": "",
  "compatibleEnvironmentTemplates": "",
  "description": "",
  "majorVersion": "",
  "source": "",
  "supportedComponentSources": "",
  "tags": "",
  "templateName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplateVersion' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "clientToken": "",\n  "compatibleEnvironmentTemplates": "",\n  "description": "",\n  "majorVersion": "",\n  "source": "",\n  "supportedComponentSources": "",\n  "tags": "",\n  "templateName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateServiceTemplateVersion'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "clientToken": "",
  "compatibleEnvironmentTemplates": "",
  "description": "",
  "majorVersion": "",
  "source": "",
  "supportedComponentSources": "",
  "tags": "",
  "templateName": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST CreateTemplateSyncConfig

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateTemplateSyncConfig

HEADERS

X-Amz-Target

BODY json

{
  "branch": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "subdirectory": "",
  "templateName": "",
  "templateType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"subdirectory\": \"\",\n  \"templateName\": \"\",\n  \"templateType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateTemplateSyncConfig" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:branch ""
                                                                                                                   :repositoryName ""
                                                                                                                   :repositoryProvider ""
                                                                                                                   :subdirectory ""
                                                                                                                   :templateName ""
                                                                                                                   :templateType ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateTemplateSyncConfig"

	payload := strings.NewReader("{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"subdirectory\": \"\",\n  \"templateName\": \"\",\n  \"templateType\": \"\"\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: 136

{
  "branch": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "subdirectory": "",
  "templateName": "",
  "templateType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateTemplateSyncConfig")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"subdirectory\": \"\",\n  \"templateName\": \"\",\n  \"templateType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

const data = JSON.stringify({
  branch: '',
  repositoryName: '',
  repositoryProvider: '',
  subdirectory: '',
  templateName: '',
  templateType: ''
});

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=AwsProton20200720.CreateTemplateSyncConfig');
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=AwsProton20200720.CreateTemplateSyncConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    branch: '',
    repositoryName: '',
    repositoryProvider: '',
    subdirectory: '',
    templateName: '',
    templateType: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateTemplateSyncConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"branch":"","repositoryName":"","repositoryProvider":"","subdirectory":"","templateName":"","templateType":""}'
};

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=AwsProton20200720.CreateTemplateSyncConfig',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "branch": "",\n  "repositoryName": "",\n  "repositoryProvider": "",\n  "subdirectory": "",\n  "templateName": "",\n  "templateType": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"subdirectory\": \"\",\n  \"templateName\": \"\",\n  \"templateType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateTemplateSyncConfig")
  .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({
  branch: '',
  repositoryName: '',
  repositoryProvider: '',
  subdirectory: '',
  templateName: '',
  templateType: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateTemplateSyncConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    branch: '',
    repositoryName: '',
    repositoryProvider: '',
    subdirectory: '',
    templateName: '',
    templateType: ''
  },
  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=AwsProton20200720.CreateTemplateSyncConfig');

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

req.type('json');
req.send({
  branch: '',
  repositoryName: '',
  repositoryProvider: '',
  subdirectory: '',
  templateName: '',
  templateType: ''
});

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=AwsProton20200720.CreateTemplateSyncConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    branch: '',
    repositoryName: '',
    repositoryProvider: '',
    subdirectory: '',
    templateName: '',
    templateType: ''
  }
};

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=AwsProton20200720.CreateTemplateSyncConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"branch":"","repositoryName":"","repositoryProvider":"","subdirectory":"","templateName":"","templateType":""}'
};

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 = @{ @"branch": @"",
                              @"repositoryName": @"",
                              @"repositoryProvider": @"",
                              @"subdirectory": @"",
                              @"templateName": @"",
                              @"templateType": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateTemplateSyncConfig",
  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([
    'branch' => '',
    'repositoryName' => '',
    'repositoryProvider' => '',
    'subdirectory' => '',
    'templateName' => '',
    'templateType' => ''
  ]),
  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=AwsProton20200720.CreateTemplateSyncConfig', [
  'body' => '{
  "branch": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "subdirectory": "",
  "templateName": "",
  "templateType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'branch' => '',
  'repositoryName' => '',
  'repositoryProvider' => '',
  'subdirectory' => '',
  'templateName' => '',
  'templateType' => ''
]));

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

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

append(json_encode([
  'branch' => '',
  'repositoryName' => '',
  'repositoryProvider' => '',
  'subdirectory' => '',
  'templateName' => '',
  'templateType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateTemplateSyncConfig');
$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=AwsProton20200720.CreateTemplateSyncConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "branch": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "subdirectory": "",
  "templateName": "",
  "templateType": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateTemplateSyncConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "branch": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "subdirectory": "",
  "templateName": "",
  "templateType": ""
}'

import http.client

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

payload = "{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"subdirectory\": \"\",\n  \"templateName\": \"\",\n  \"templateType\": \"\"\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=AwsProton20200720.CreateTemplateSyncConfig"

payload = {
    "branch": "",
    "repositoryName": "",
    "repositoryProvider": "",
    "subdirectory": "",
    "templateName": "",
    "templateType": ""
}
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=AwsProton20200720.CreateTemplateSyncConfig"

payload <- "{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"subdirectory\": \"\",\n  \"templateName\": \"\",\n  \"templateType\": \"\"\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=AwsProton20200720.CreateTemplateSyncConfig")

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  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"subdirectory\": \"\",\n  \"templateName\": \"\",\n  \"templateType\": \"\"\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  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"subdirectory\": \"\",\n  \"templateName\": \"\",\n  \"templateType\": \"\"\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=AwsProton20200720.CreateTemplateSyncConfig";

    let payload = json!({
        "branch": "",
        "repositoryName": "",
        "repositoryProvider": "",
        "subdirectory": "",
        "templateName": "",
        "templateType": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateTemplateSyncConfig' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "branch": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "subdirectory": "",
  "templateName": "",
  "templateType": ""
}'

echo '{
  "branch": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "subdirectory": "",
  "templateName": "",
  "templateType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateTemplateSyncConfig' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "branch": "",\n  "repositoryName": "",\n  "repositoryProvider": "",\n  "subdirectory": "",\n  "templateName": "",\n  "templateType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.CreateTemplateSyncConfig'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "branch": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "subdirectory": "",
  "templateName": "",
  "templateType": ""
] as [String : Any]

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

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

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

dataTask.resume()

POST DeleteComponent

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteComponent

HEADERS

X-Amz-Target

BODY json

{
  "name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteComponent"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\"\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteComponent"

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

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

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

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

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

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

}

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

{
  "name": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteComponent');
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=AwsProton20200720.DeleteComponent',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: ''}
};

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

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

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

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

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteComponent")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({name: ''}));
req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

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

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

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

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

#import 

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteComponent",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

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

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteComponent"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteComponent"

payload <- "{\n  \"name\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

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

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteComponent' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "name": ""
}'

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

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

import Foundation

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

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

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

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

dataTask.resume()

POST DeleteEnvironment

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironment

HEADERS

X-Amz-Target

BODY json

{
  "name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironment"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\"\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironment"

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

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

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

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

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

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

}

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

{
  "name": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironment');
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=AwsProton20200720.DeleteEnvironment',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: ''}
};

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

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

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

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

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironment")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({name: ''}));
req.end();

const request = require('request');

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

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

  console.log(body);
});

const unirest = require('unirest');

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

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

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

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

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

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

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

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

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

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

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

#import 

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironment",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

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

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironment"

payload = { "name": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironment"

payload <- "{\n  \"name\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironment")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironment";

    let payload = json!({"name": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironment' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "name": ""
}'

echo '{
  "name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironment' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironment'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironment")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteEnvironmentAccountConnection

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentAccountConnection

HEADERS

X-Amz-Target

BODY json

{
  "id": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentAccountConnection");

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  \"id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentAccountConnection" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:id ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentAccountConnection"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": \"\"\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=AwsProton20200720.DeleteEnvironmentAccountConnection"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"id\": \"\"\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=AwsProton20200720.DeleteEnvironmentAccountConnection");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentAccountConnection"

	payload := strings.NewReader("{\n  \"id\": \"\"\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: 14

{
  "id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentAccountConnection")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentAccountConnection"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"id\": \"\"\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  \"id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentAccountConnection")
  .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=AwsProton20200720.DeleteEnvironmentAccountConnection")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  id: ''
});

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=AwsProton20200720.DeleteEnvironmentAccountConnection');
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=AwsProton20200720.DeleteEnvironmentAccountConnection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentAccountConnection';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"id":""}'
};

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=AwsProton20200720.DeleteEnvironmentAccountConnection',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentAccountConnection")
  .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({id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentAccountConnection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {id: ''},
  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=AwsProton20200720.DeleteEnvironmentAccountConnection');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  id: ''
});

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=AwsProton20200720.DeleteEnvironmentAccountConnection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {id: ''}
};

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=AwsProton20200720.DeleteEnvironmentAccountConnection';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"id":""}'
};

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 = @{ @"id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentAccountConnection"]
                                                       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=AwsProton20200720.DeleteEnvironmentAccountConnection" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"id\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentAccountConnection",
  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([
    'id' => ''
  ]),
  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=AwsProton20200720.DeleteEnvironmentAccountConnection', [
  'body' => '{
  "id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentAccountConnection');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentAccountConnection');
$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=AwsProton20200720.DeleteEnvironmentAccountConnection' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentAccountConnection' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"id\": \"\"\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=AwsProton20200720.DeleteEnvironmentAccountConnection"

payload = { "id": "" }
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=AwsProton20200720.DeleteEnvironmentAccountConnection"

payload <- "{\n  \"id\": \"\"\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=AwsProton20200720.DeleteEnvironmentAccountConnection")

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  \"id\": \"\"\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  \"id\": \"\"\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=AwsProton20200720.DeleteEnvironmentAccountConnection";

    let payload = json!({"id": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentAccountConnection' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "id": ""
}'

echo '{
  "id": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentAccountConnection' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentAccountConnection'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["id": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentAccountConnection")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteEnvironmentTemplate

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate

HEADERS

X-Amz-Target

BODY json

{
  "name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate"

	payload := strings.NewReader("{\n  \"name\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate")
  .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=AwsProton20200720.DeleteEnvironmentTemplate")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate');
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=AwsProton20200720.DeleteEnvironmentTemplate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate"]
                                                       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=AwsProton20200720.DeleteEnvironmentTemplate" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate', [
  'body' => '{
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate');
$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=AwsProton20200720.DeleteEnvironmentTemplate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"name\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate"

payload = { "name": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate"

payload <- "{\n  \"name\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate";

    let payload = json!({"name": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "name": ""
}'

echo '{
  "name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteEnvironmentTemplateVersion

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplateVersion

HEADERS

X-Amz-Target

BODY json

{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplateVersion");

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  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplateVersion" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:majorVersion ""
                                                                                                                           :minorVersion ""
                                                                                                                           :templateName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplateVersion"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.DeleteEnvironmentTemplateVersion"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.DeleteEnvironmentTemplateVersion");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplateVersion"

	payload := strings.NewReader("{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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: 68

{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplateVersion")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplateVersion"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplateVersion")
  .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=AwsProton20200720.DeleteEnvironmentTemplateVersion")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  majorVersion: '',
  minorVersion: '',
  templateName: ''
});

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=AwsProton20200720.DeleteEnvironmentTemplateVersion');
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=AwsProton20200720.DeleteEnvironmentTemplateVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {majorVersion: '', minorVersion: '', templateName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplateVersion';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"majorVersion":"","minorVersion":"","templateName":""}'
};

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=AwsProton20200720.DeleteEnvironmentTemplateVersion',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "majorVersion": "",\n  "minorVersion": "",\n  "templateName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplateVersion")
  .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({majorVersion: '', minorVersion: '', templateName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplateVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {majorVersion: '', minorVersion: '', templateName: ''},
  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=AwsProton20200720.DeleteEnvironmentTemplateVersion');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  majorVersion: '',
  minorVersion: '',
  templateName: ''
});

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=AwsProton20200720.DeleteEnvironmentTemplateVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {majorVersion: '', minorVersion: '', templateName: ''}
};

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=AwsProton20200720.DeleteEnvironmentTemplateVersion';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"majorVersion":"","minorVersion":"","templateName":""}'
};

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 = @{ @"majorVersion": @"",
                              @"minorVersion": @"",
                              @"templateName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplateVersion"]
                                                       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=AwsProton20200720.DeleteEnvironmentTemplateVersion" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplateVersion",
  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([
    'majorVersion' => '',
    'minorVersion' => '',
    'templateName' => ''
  ]),
  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=AwsProton20200720.DeleteEnvironmentTemplateVersion', [
  'body' => '{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplateVersion');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'majorVersion' => '',
  'minorVersion' => '',
  'templateName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'majorVersion' => '',
  'minorVersion' => '',
  'templateName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplateVersion');
$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=AwsProton20200720.DeleteEnvironmentTemplateVersion' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplateVersion' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.DeleteEnvironmentTemplateVersion"

payload = {
    "majorVersion": "",
    "minorVersion": "",
    "templateName": ""
}
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=AwsProton20200720.DeleteEnvironmentTemplateVersion"

payload <- "{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.DeleteEnvironmentTemplateVersion")

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  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.DeleteEnvironmentTemplateVersion";

    let payload = json!({
        "majorVersion": "",
        "minorVersion": "",
        "templateName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplateVersion' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}'

echo '{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplateVersion' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "majorVersion": "",\n  "minorVersion": "",\n  "templateName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplateVersion'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteEnvironmentTemplateVersion")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteRepository

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteRepository

HEADERS

X-Amz-Target

BODY json

{
  "name": "",
  "provider": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteRepository");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\",\n  \"provider\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteRepository" {:headers {:x-amz-target ""}
                                                                                             :content-type :json
                                                                                             :form-params {:name ""
                                                                                                           :provider ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteRepository"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"provider\": \"\"\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=AwsProton20200720.DeleteRepository"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"name\": \"\",\n  \"provider\": \"\"\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=AwsProton20200720.DeleteRepository");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"provider\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteRepository"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"provider\": \"\"\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: 34

{
  "name": "",
  "provider": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteRepository")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"provider\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteRepository"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"provider\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"provider\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteRepository")
  .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=AwsProton20200720.DeleteRepository")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"provider\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  provider: ''
});

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=AwsProton20200720.DeleteRepository');
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=AwsProton20200720.DeleteRepository',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: '', provider: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteRepository';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":"","provider":""}'
};

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=AwsProton20200720.DeleteRepository',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "provider": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"provider\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteRepository")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({name: '', provider: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteRepository',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {name: '', provider: ''},
  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=AwsProton20200720.DeleteRepository');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: '',
  provider: ''
});

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=AwsProton20200720.DeleteRepository',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: '', provider: ''}
};

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=AwsProton20200720.DeleteRepository';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":"","provider":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"name": @"",
                              @"provider": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteRepository"]
                                                       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=AwsProton20200720.DeleteRepository" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"provider\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteRepository",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => '',
    'provider' => ''
  ]),
  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=AwsProton20200720.DeleteRepository', [
  'body' => '{
  "name": "",
  "provider": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteRepository');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'provider' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'name' => '',
  'provider' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteRepository');
$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=AwsProton20200720.DeleteRepository' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "provider": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteRepository' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "provider": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"name\": \"\",\n  \"provider\": \"\"\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=AwsProton20200720.DeleteRepository"

payload = {
    "name": "",
    "provider": ""
}
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=AwsProton20200720.DeleteRepository"

payload <- "{\n  \"name\": \"\",\n  \"provider\": \"\"\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=AwsProton20200720.DeleteRepository")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"provider\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"name\": \"\",\n  \"provider\": \"\"\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=AwsProton20200720.DeleteRepository";

    let payload = json!({
        "name": "",
        "provider": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteRepository' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "name": "",
  "provider": ""
}'

echo '{
  "name": "",
  "provider": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteRepository' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "provider": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteRepository'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "name": "",
  "provider": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteRepository")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteService

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService

HEADERS

X-Amz-Target

BODY json

{
  "name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService" {:headers {:x-amz-target ""}
                                                                                          :content-type :json
                                                                                          :form-params {:name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService"

	payload := strings.NewReader("{\n  \"name\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService")
  .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=AwsProton20200720.DeleteService")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService');
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=AwsProton20200720.DeleteService',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService"]
                                                       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=AwsProton20200720.DeleteService" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService', [
  'body' => '{
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService');
$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=AwsProton20200720.DeleteService' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"name\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService"

payload = { "name": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService"

payload <- "{\n  \"name\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService";

    let payload = json!({"name": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "name": ""
}'

echo '{
  "name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteService")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteServiceSyncConfig

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceSyncConfig

HEADERS

X-Amz-Target

BODY json

{
  "serviceName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceSyncConfig");

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  \"serviceName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceSyncConfig" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:serviceName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceSyncConfig"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"serviceName\": \"\"\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=AwsProton20200720.DeleteServiceSyncConfig"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"serviceName\": \"\"\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=AwsProton20200720.DeleteServiceSyncConfig");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"serviceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceSyncConfig"

	payload := strings.NewReader("{\n  \"serviceName\": \"\"\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

{
  "serviceName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceSyncConfig")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"serviceName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceSyncConfig"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"serviceName\": \"\"\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  \"serviceName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceSyncConfig")
  .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=AwsProton20200720.DeleteServiceSyncConfig")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"serviceName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  serviceName: ''
});

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=AwsProton20200720.DeleteServiceSyncConfig');
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=AwsProton20200720.DeleteServiceSyncConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {serviceName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceSyncConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"serviceName":""}'
};

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=AwsProton20200720.DeleteServiceSyncConfig',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "serviceName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"serviceName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceSyncConfig")
  .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({serviceName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceSyncConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {serviceName: ''},
  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=AwsProton20200720.DeleteServiceSyncConfig');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  serviceName: ''
});

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=AwsProton20200720.DeleteServiceSyncConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {serviceName: ''}
};

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=AwsProton20200720.DeleteServiceSyncConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"serviceName":""}'
};

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 = @{ @"serviceName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceSyncConfig"]
                                                       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=AwsProton20200720.DeleteServiceSyncConfig" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"serviceName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceSyncConfig",
  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([
    'serviceName' => ''
  ]),
  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=AwsProton20200720.DeleteServiceSyncConfig', [
  'body' => '{
  "serviceName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceSyncConfig');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'serviceName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'serviceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceSyncConfig');
$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=AwsProton20200720.DeleteServiceSyncConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "serviceName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceSyncConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "serviceName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"serviceName\": \"\"\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=AwsProton20200720.DeleteServiceSyncConfig"

payload = { "serviceName": "" }
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=AwsProton20200720.DeleteServiceSyncConfig"

payload <- "{\n  \"serviceName\": \"\"\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=AwsProton20200720.DeleteServiceSyncConfig")

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  \"serviceName\": \"\"\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  \"serviceName\": \"\"\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=AwsProton20200720.DeleteServiceSyncConfig";

    let payload = json!({"serviceName": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceSyncConfig' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "serviceName": ""
}'

echo '{
  "serviceName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceSyncConfig' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "serviceName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceSyncConfig'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["serviceName": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceSyncConfig")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteServiceTemplate

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate

HEADERS

X-Amz-Target

BODY json

{
  "name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate"

	payload := strings.NewReader("{\n  \"name\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate")
  .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=AwsProton20200720.DeleteServiceTemplate")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate');
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=AwsProton20200720.DeleteServiceTemplate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate"]
                                                       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=AwsProton20200720.DeleteServiceTemplate" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate', [
  'body' => '{
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate');
$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=AwsProton20200720.DeleteServiceTemplate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"name\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate"

payload = { "name": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate"

payload <- "{\n  \"name\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate";

    let payload = json!({"name": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "name": ""
}'

echo '{
  "name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteServiceTemplateVersion

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplateVersion

HEADERS

X-Amz-Target

BODY json

{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplateVersion");

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  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplateVersion" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:majorVersion ""
                                                                                                                       :minorVersion ""
                                                                                                                       :templateName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplateVersion"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.DeleteServiceTemplateVersion"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.DeleteServiceTemplateVersion");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplateVersion"

	payload := strings.NewReader("{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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: 68

{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplateVersion")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplateVersion"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplateVersion")
  .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=AwsProton20200720.DeleteServiceTemplateVersion")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  majorVersion: '',
  minorVersion: '',
  templateName: ''
});

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=AwsProton20200720.DeleteServiceTemplateVersion');
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=AwsProton20200720.DeleteServiceTemplateVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {majorVersion: '', minorVersion: '', templateName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplateVersion';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"majorVersion":"","minorVersion":"","templateName":""}'
};

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=AwsProton20200720.DeleteServiceTemplateVersion',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "majorVersion": "",\n  "minorVersion": "",\n  "templateName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplateVersion")
  .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({majorVersion: '', minorVersion: '', templateName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplateVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {majorVersion: '', minorVersion: '', templateName: ''},
  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=AwsProton20200720.DeleteServiceTemplateVersion');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  majorVersion: '',
  minorVersion: '',
  templateName: ''
});

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=AwsProton20200720.DeleteServiceTemplateVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {majorVersion: '', minorVersion: '', templateName: ''}
};

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=AwsProton20200720.DeleteServiceTemplateVersion';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"majorVersion":"","minorVersion":"","templateName":""}'
};

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 = @{ @"majorVersion": @"",
                              @"minorVersion": @"",
                              @"templateName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplateVersion"]
                                                       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=AwsProton20200720.DeleteServiceTemplateVersion" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplateVersion",
  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([
    'majorVersion' => '',
    'minorVersion' => '',
    'templateName' => ''
  ]),
  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=AwsProton20200720.DeleteServiceTemplateVersion', [
  'body' => '{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplateVersion');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'majorVersion' => '',
  'minorVersion' => '',
  'templateName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'majorVersion' => '',
  'minorVersion' => '',
  'templateName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplateVersion');
$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=AwsProton20200720.DeleteServiceTemplateVersion' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplateVersion' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.DeleteServiceTemplateVersion"

payload = {
    "majorVersion": "",
    "minorVersion": "",
    "templateName": ""
}
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=AwsProton20200720.DeleteServiceTemplateVersion"

payload <- "{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.DeleteServiceTemplateVersion")

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  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.DeleteServiceTemplateVersion";

    let payload = json!({
        "majorVersion": "",
        "minorVersion": "",
        "templateName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplateVersion' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}'

echo '{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplateVersion' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "majorVersion": "",\n  "minorVersion": "",\n  "templateName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplateVersion'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteServiceTemplateVersion")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST DeleteTemplateSyncConfig

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteTemplateSyncConfig

HEADERS

X-Amz-Target

BODY json

{
  "templateName": "",
  "templateType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteTemplateSyncConfig");

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  \"templateName\": \"\",\n  \"templateType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteTemplateSyncConfig" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:templateName ""
                                                                                                                   :templateType ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteTemplateSyncConfig"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"templateName\": \"\",\n  \"templateType\": \"\"\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=AwsProton20200720.DeleteTemplateSyncConfig"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"templateName\": \"\",\n  \"templateType\": \"\"\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=AwsProton20200720.DeleteTemplateSyncConfig");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"templateName\": \"\",\n  \"templateType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteTemplateSyncConfig"

	payload := strings.NewReader("{\n  \"templateName\": \"\",\n  \"templateType\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 46

{
  "templateName": "",
  "templateType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteTemplateSyncConfig")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"templateName\": \"\",\n  \"templateType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteTemplateSyncConfig"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"templateName\": \"\",\n  \"templateType\": \"\"\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  \"templateName\": \"\",\n  \"templateType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteTemplateSyncConfig")
  .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=AwsProton20200720.DeleteTemplateSyncConfig")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"templateName\": \"\",\n  \"templateType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  templateName: '',
  templateType: ''
});

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=AwsProton20200720.DeleteTemplateSyncConfig');
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=AwsProton20200720.DeleteTemplateSyncConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {templateName: '', templateType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteTemplateSyncConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"templateName":"","templateType":""}'
};

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=AwsProton20200720.DeleteTemplateSyncConfig',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "templateName": "",\n  "templateType": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"templateName\": \"\",\n  \"templateType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteTemplateSyncConfig")
  .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({templateName: '', templateType: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteTemplateSyncConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {templateName: '', templateType: ''},
  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=AwsProton20200720.DeleteTemplateSyncConfig');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  templateName: '',
  templateType: ''
});

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=AwsProton20200720.DeleteTemplateSyncConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {templateName: '', templateType: ''}
};

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=AwsProton20200720.DeleteTemplateSyncConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"templateName":"","templateType":""}'
};

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 = @{ @"templateName": @"",
                              @"templateType": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteTemplateSyncConfig"]
                                                       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=AwsProton20200720.DeleteTemplateSyncConfig" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"templateName\": \"\",\n  \"templateType\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteTemplateSyncConfig",
  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([
    'templateName' => '',
    'templateType' => ''
  ]),
  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=AwsProton20200720.DeleteTemplateSyncConfig', [
  'body' => '{
  "templateName": "",
  "templateType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteTemplateSyncConfig');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'templateName' => '',
  'templateType' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'templateName' => '',
  'templateType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteTemplateSyncConfig');
$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=AwsProton20200720.DeleteTemplateSyncConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "templateName": "",
  "templateType": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteTemplateSyncConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "templateName": "",
  "templateType": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"templateName\": \"\",\n  \"templateType\": \"\"\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=AwsProton20200720.DeleteTemplateSyncConfig"

payload = {
    "templateName": "",
    "templateType": ""
}
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=AwsProton20200720.DeleteTemplateSyncConfig"

payload <- "{\n  \"templateName\": \"\",\n  \"templateType\": \"\"\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=AwsProton20200720.DeleteTemplateSyncConfig")

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  \"templateName\": \"\",\n  \"templateType\": \"\"\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  \"templateName\": \"\",\n  \"templateType\": \"\"\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=AwsProton20200720.DeleteTemplateSyncConfig";

    let payload = json!({
        "templateName": "",
        "templateType": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteTemplateSyncConfig' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "templateName": "",
  "templateType": ""
}'

echo '{
  "templateName": "",
  "templateType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteTemplateSyncConfig' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "templateName": "",\n  "templateType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteTemplateSyncConfig'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "templateName": "",
  "templateType": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.DeleteTemplateSyncConfig")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetAccountSettings

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetAccountSettings

HEADERS

X-Amz-Target

BODY json

{}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetAccountSettings");

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=AwsProton20200720.GetAccountSettings" {:headers {:x-amz-target ""}
                                                                                               :content-type :json})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetAccountSettings"
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=AwsProton20200720.GetAccountSettings"),
    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=AwsProton20200720.GetAccountSettings");
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=AwsProton20200720.GetAccountSettings"

	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=AwsProton20200720.GetAccountSettings")
  .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=AwsProton20200720.GetAccountSettings"))
    .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=AwsProton20200720.GetAccountSettings")
  .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=AwsProton20200720.GetAccountSettings")
  .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=AwsProton20200720.GetAccountSettings');
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=AwsProton20200720.GetAccountSettings',
  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=AwsProton20200720.GetAccountSettings';
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=AwsProton20200720.GetAccountSettings',
  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=AwsProton20200720.GetAccountSettings")
  .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=AwsProton20200720.GetAccountSettings',
  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=AwsProton20200720.GetAccountSettings');

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=AwsProton20200720.GetAccountSettings',
  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=AwsProton20200720.GetAccountSettings';
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=AwsProton20200720.GetAccountSettings"]
                                                       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=AwsProton20200720.GetAccountSettings" 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=AwsProton20200720.GetAccountSettings",
  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=AwsProton20200720.GetAccountSettings', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetAccountSettings');
$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=AwsProton20200720.GetAccountSettings');
$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=AwsProton20200720.GetAccountSettings' -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=AwsProton20200720.GetAccountSettings' -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=AwsProton20200720.GetAccountSettings"

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=AwsProton20200720.GetAccountSettings"

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=AwsProton20200720.GetAccountSettings")

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=AwsProton20200720.GetAccountSettings";

    let payload = json!({});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetAccountSettings' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{}'

echo '{}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetAccountSettings' \
  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=AwsProton20200720.GetAccountSettings'

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=AwsProton20200720.GetAccountSettings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetComponent

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent

HEADERS

X-Amz-Target

BODY json

{
  "name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent" {:headers {:x-amz-target ""}
                                                                                         :content-type :json
                                                                                         :form-params {:name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent"

	payload := strings.NewReader("{\n  \"name\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent")
  .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=AwsProton20200720.GetComponent")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent');
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=AwsProton20200720.GetComponent',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent"]
                                                       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=AwsProton20200720.GetComponent" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent', [
  'body' => '{
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent');
$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=AwsProton20200720.GetComponent' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"name\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent"

payload = { "name": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent"

payload <- "{\n  \"name\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent";

    let payload = json!({"name": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "name": ""
}'

echo '{
  "name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetComponent")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetEnvironment

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment

HEADERS

X-Amz-Target

BODY json

{
  "name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment" {:headers {:x-amz-target ""}
                                                                                           :content-type :json
                                                                                           :form-params {:name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment"

	payload := strings.NewReader("{\n  \"name\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment")
  .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=AwsProton20200720.GetEnvironment")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment');
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=AwsProton20200720.GetEnvironment',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment"]
                                                       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=AwsProton20200720.GetEnvironment" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment', [
  'body' => '{
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment');
$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=AwsProton20200720.GetEnvironment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"name\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment"

payload = { "name": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment"

payload <- "{\n  \"name\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment";

    let payload = json!({"name": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "name": ""
}'

echo '{
  "name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironment")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetEnvironmentAccountConnection

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentAccountConnection

HEADERS

X-Amz-Target

BODY json

{
  "id": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentAccountConnection");

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  \"id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentAccountConnection" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:id ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentAccountConnection"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": \"\"\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=AwsProton20200720.GetEnvironmentAccountConnection"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"id\": \"\"\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=AwsProton20200720.GetEnvironmentAccountConnection");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentAccountConnection"

	payload := strings.NewReader("{\n  \"id\": \"\"\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: 14

{
  "id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentAccountConnection")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentAccountConnection"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"id\": \"\"\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  \"id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentAccountConnection")
  .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=AwsProton20200720.GetEnvironmentAccountConnection")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  id: ''
});

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=AwsProton20200720.GetEnvironmentAccountConnection');
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=AwsProton20200720.GetEnvironmentAccountConnection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentAccountConnection';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"id":""}'
};

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=AwsProton20200720.GetEnvironmentAccountConnection',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentAccountConnection")
  .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({id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentAccountConnection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {id: ''},
  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=AwsProton20200720.GetEnvironmentAccountConnection');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  id: ''
});

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=AwsProton20200720.GetEnvironmentAccountConnection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {id: ''}
};

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=AwsProton20200720.GetEnvironmentAccountConnection';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"id":""}'
};

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 = @{ @"id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentAccountConnection"]
                                                       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=AwsProton20200720.GetEnvironmentAccountConnection" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"id\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentAccountConnection",
  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([
    'id' => ''
  ]),
  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=AwsProton20200720.GetEnvironmentAccountConnection', [
  'body' => '{
  "id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentAccountConnection');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentAccountConnection');
$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=AwsProton20200720.GetEnvironmentAccountConnection' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentAccountConnection' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"id\": \"\"\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=AwsProton20200720.GetEnvironmentAccountConnection"

payload = { "id": "" }
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=AwsProton20200720.GetEnvironmentAccountConnection"

payload <- "{\n  \"id\": \"\"\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=AwsProton20200720.GetEnvironmentAccountConnection")

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  \"id\": \"\"\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  \"id\": \"\"\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=AwsProton20200720.GetEnvironmentAccountConnection";

    let payload = json!({"id": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentAccountConnection' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "id": ""
}'

echo '{
  "id": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentAccountConnection' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentAccountConnection'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["id": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentAccountConnection")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetEnvironmentTemplate

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate

HEADERS

X-Amz-Target

BODY json

{
  "name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate" {:headers {:x-amz-target ""}
                                                                                                   :content-type :json
                                                                                                   :form-params {:name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate"

	payload := strings.NewReader("{\n  \"name\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate")
  .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=AwsProton20200720.GetEnvironmentTemplate")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate');
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=AwsProton20200720.GetEnvironmentTemplate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate"]
                                                       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=AwsProton20200720.GetEnvironmentTemplate" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate', [
  'body' => '{
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate');
$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=AwsProton20200720.GetEnvironmentTemplate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"name\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate"

payload = { "name": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate"

payload <- "{\n  \"name\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate";

    let payload = json!({"name": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "name": ""
}'

echo '{
  "name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetEnvironmentTemplateVersion

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplateVersion

HEADERS

X-Amz-Target

BODY json

{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplateVersion");

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  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplateVersion" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:majorVersion ""
                                                                                                                        :minorVersion ""
                                                                                                                        :templateName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplateVersion"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.GetEnvironmentTemplateVersion"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.GetEnvironmentTemplateVersion");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplateVersion"

	payload := strings.NewReader("{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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: 68

{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplateVersion")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplateVersion"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplateVersion")
  .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=AwsProton20200720.GetEnvironmentTemplateVersion")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  majorVersion: '',
  minorVersion: '',
  templateName: ''
});

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=AwsProton20200720.GetEnvironmentTemplateVersion');
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=AwsProton20200720.GetEnvironmentTemplateVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {majorVersion: '', minorVersion: '', templateName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplateVersion';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"majorVersion":"","minorVersion":"","templateName":""}'
};

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=AwsProton20200720.GetEnvironmentTemplateVersion',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "majorVersion": "",\n  "minorVersion": "",\n  "templateName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplateVersion")
  .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({majorVersion: '', minorVersion: '', templateName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplateVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {majorVersion: '', minorVersion: '', templateName: ''},
  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=AwsProton20200720.GetEnvironmentTemplateVersion');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  majorVersion: '',
  minorVersion: '',
  templateName: ''
});

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=AwsProton20200720.GetEnvironmentTemplateVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {majorVersion: '', minorVersion: '', templateName: ''}
};

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=AwsProton20200720.GetEnvironmentTemplateVersion';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"majorVersion":"","minorVersion":"","templateName":""}'
};

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 = @{ @"majorVersion": @"",
                              @"minorVersion": @"",
                              @"templateName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplateVersion"]
                                                       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=AwsProton20200720.GetEnvironmentTemplateVersion" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplateVersion",
  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([
    'majorVersion' => '',
    'minorVersion' => '',
    'templateName' => ''
  ]),
  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=AwsProton20200720.GetEnvironmentTemplateVersion', [
  'body' => '{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplateVersion');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'majorVersion' => '',
  'minorVersion' => '',
  'templateName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'majorVersion' => '',
  'minorVersion' => '',
  'templateName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplateVersion');
$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=AwsProton20200720.GetEnvironmentTemplateVersion' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplateVersion' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.GetEnvironmentTemplateVersion"

payload = {
    "majorVersion": "",
    "minorVersion": "",
    "templateName": ""
}
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=AwsProton20200720.GetEnvironmentTemplateVersion"

payload <- "{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.GetEnvironmentTemplateVersion")

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  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.GetEnvironmentTemplateVersion";

    let payload = json!({
        "majorVersion": "",
        "minorVersion": "",
        "templateName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplateVersion' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}'

echo '{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplateVersion' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "majorVersion": "",\n  "minorVersion": "",\n  "templateName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplateVersion'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetEnvironmentTemplateVersion")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetRepository

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepository

HEADERS

X-Amz-Target

BODY json

{
  "name": "",
  "provider": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepository");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\",\n  \"provider\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepository" {:headers {:x-amz-target ""}
                                                                                          :content-type :json
                                                                                          :form-params {:name ""
                                                                                                        :provider ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepository"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"provider\": \"\"\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=AwsProton20200720.GetRepository"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"name\": \"\",\n  \"provider\": \"\"\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=AwsProton20200720.GetRepository");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"provider\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepository"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"provider\": \"\"\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: 34

{
  "name": "",
  "provider": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepository")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"provider\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepository"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"provider\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"provider\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepository")
  .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=AwsProton20200720.GetRepository")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"provider\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  provider: ''
});

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=AwsProton20200720.GetRepository');
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=AwsProton20200720.GetRepository',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: '', provider: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepository';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":"","provider":""}'
};

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=AwsProton20200720.GetRepository',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "provider": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"provider\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepository")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({name: '', provider: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepository',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {name: '', provider: ''},
  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=AwsProton20200720.GetRepository');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: '',
  provider: ''
});

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=AwsProton20200720.GetRepository',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: '', provider: ''}
};

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=AwsProton20200720.GetRepository';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":"","provider":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"name": @"",
                              @"provider": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepository"]
                                                       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=AwsProton20200720.GetRepository" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"provider\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepository",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => '',
    'provider' => ''
  ]),
  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=AwsProton20200720.GetRepository', [
  'body' => '{
  "name": "",
  "provider": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepository');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'provider' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'name' => '',
  'provider' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepository');
$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=AwsProton20200720.GetRepository' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "provider": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepository' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "provider": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"name\": \"\",\n  \"provider\": \"\"\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=AwsProton20200720.GetRepository"

payload = {
    "name": "",
    "provider": ""
}
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=AwsProton20200720.GetRepository"

payload <- "{\n  \"name\": \"\",\n  \"provider\": \"\"\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=AwsProton20200720.GetRepository")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"provider\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"name\": \"\",\n  \"provider\": \"\"\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=AwsProton20200720.GetRepository";

    let payload = json!({
        "name": "",
        "provider": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepository' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "name": "",
  "provider": ""
}'

echo '{
  "name": "",
  "provider": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepository' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "provider": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepository'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "name": "",
  "provider": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepository")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetRepositorySyncStatus

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepositorySyncStatus

HEADERS

X-Amz-Target

BODY json

{
  "branch": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "syncType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepositorySyncStatus");

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  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepositorySyncStatus" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:branch ""
                                                                                                                  :repositoryName ""
                                                                                                                  :repositoryProvider ""
                                                                                                                  :syncType ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepositorySyncStatus"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\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=AwsProton20200720.GetRepositorySyncStatus"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\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=AwsProton20200720.GetRepositorySyncStatus");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepositorySyncStatus"

	payload := strings.NewReader("{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\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

{
  "branch": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "syncType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepositorySyncStatus")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepositorySyncStatus"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\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  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepositorySyncStatus")
  .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=AwsProton20200720.GetRepositorySyncStatus")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  branch: '',
  repositoryName: '',
  repositoryProvider: '',
  syncType: ''
});

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=AwsProton20200720.GetRepositorySyncStatus');
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=AwsProton20200720.GetRepositorySyncStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {branch: '', repositoryName: '', repositoryProvider: '', syncType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepositorySyncStatus';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"branch":"","repositoryName":"","repositoryProvider":"","syncType":""}'
};

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=AwsProton20200720.GetRepositorySyncStatus',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "branch": "",\n  "repositoryName": "",\n  "repositoryProvider": "",\n  "syncType": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepositorySyncStatus")
  .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({branch: '', repositoryName: '', repositoryProvider: '', syncType: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepositorySyncStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {branch: '', repositoryName: '', repositoryProvider: '', syncType: ''},
  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=AwsProton20200720.GetRepositorySyncStatus');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  branch: '',
  repositoryName: '',
  repositoryProvider: '',
  syncType: ''
});

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=AwsProton20200720.GetRepositorySyncStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {branch: '', repositoryName: '', repositoryProvider: '', syncType: ''}
};

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=AwsProton20200720.GetRepositorySyncStatus';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"branch":"","repositoryName":"","repositoryProvider":"","syncType":""}'
};

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 = @{ @"branch": @"",
                              @"repositoryName": @"",
                              @"repositoryProvider": @"",
                              @"syncType": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepositorySyncStatus"]
                                                       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=AwsProton20200720.GetRepositorySyncStatus" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepositorySyncStatus",
  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([
    'branch' => '',
    'repositoryName' => '',
    'repositoryProvider' => '',
    'syncType' => ''
  ]),
  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=AwsProton20200720.GetRepositorySyncStatus', [
  'body' => '{
  "branch": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "syncType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepositorySyncStatus');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'branch' => '',
  'repositoryName' => '',
  'repositoryProvider' => '',
  'syncType' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'branch' => '',
  'repositoryName' => '',
  'repositoryProvider' => '',
  'syncType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepositorySyncStatus');
$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=AwsProton20200720.GetRepositorySyncStatus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "branch": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "syncType": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepositorySyncStatus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "branch": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "syncType": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\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=AwsProton20200720.GetRepositorySyncStatus"

payload = {
    "branch": "",
    "repositoryName": "",
    "repositoryProvider": "",
    "syncType": ""
}
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=AwsProton20200720.GetRepositorySyncStatus"

payload <- "{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\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=AwsProton20200720.GetRepositorySyncStatus")

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  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\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  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\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=AwsProton20200720.GetRepositorySyncStatus";

    let payload = json!({
        "branch": "",
        "repositoryName": "",
        "repositoryProvider": "",
        "syncType": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepositorySyncStatus' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "branch": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "syncType": ""
}'

echo '{
  "branch": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "syncType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepositorySyncStatus' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "branch": "",\n  "repositoryName": "",\n  "repositoryProvider": "",\n  "syncType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepositorySyncStatus'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "branch": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "syncType": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetRepositorySyncStatus")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetResourcesSummary

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetResourcesSummary

HEADERS

X-Amz-Target

BODY json

{}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetResourcesSummary");

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=AwsProton20200720.GetResourcesSummary" {:headers {:x-amz-target ""}
                                                                                                :content-type :json})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetResourcesSummary"
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=AwsProton20200720.GetResourcesSummary"),
    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=AwsProton20200720.GetResourcesSummary");
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=AwsProton20200720.GetResourcesSummary"

	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=AwsProton20200720.GetResourcesSummary")
  .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=AwsProton20200720.GetResourcesSummary"))
    .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=AwsProton20200720.GetResourcesSummary")
  .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=AwsProton20200720.GetResourcesSummary")
  .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=AwsProton20200720.GetResourcesSummary');
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=AwsProton20200720.GetResourcesSummary',
  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=AwsProton20200720.GetResourcesSummary';
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=AwsProton20200720.GetResourcesSummary',
  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=AwsProton20200720.GetResourcesSummary")
  .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=AwsProton20200720.GetResourcesSummary',
  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=AwsProton20200720.GetResourcesSummary');

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=AwsProton20200720.GetResourcesSummary',
  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=AwsProton20200720.GetResourcesSummary';
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=AwsProton20200720.GetResourcesSummary"]
                                                       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=AwsProton20200720.GetResourcesSummary" 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=AwsProton20200720.GetResourcesSummary",
  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=AwsProton20200720.GetResourcesSummary', [
  'body' => '{}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetResourcesSummary');
$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=AwsProton20200720.GetResourcesSummary');
$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=AwsProton20200720.GetResourcesSummary' -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=AwsProton20200720.GetResourcesSummary' -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=AwsProton20200720.GetResourcesSummary"

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=AwsProton20200720.GetResourcesSummary"

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=AwsProton20200720.GetResourcesSummary")

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=AwsProton20200720.GetResourcesSummary";

    let payload = json!({});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetResourcesSummary' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{}'

echo '{}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetResourcesSummary' \
  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=AwsProton20200720.GetResourcesSummary'

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=AwsProton20200720.GetResourcesSummary")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetService

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService

HEADERS

X-Amz-Target

BODY json

{
  "name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService" {:headers {:x-amz-target ""}
                                                                                       :content-type :json
                                                                                       :form-params {:name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService"

	payload := strings.NewReader("{\n  \"name\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService")
  .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=AwsProton20200720.GetService")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService');
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=AwsProton20200720.GetService',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService"]
                                                       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=AwsProton20200720.GetService" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService', [
  'body' => '{
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService');
$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=AwsProton20200720.GetService' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"name\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService"

payload = { "name": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService"

payload <- "{\n  \"name\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService";

    let payload = json!({"name": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "name": ""
}'

echo '{
  "name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetService")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetServiceInstance

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstance

HEADERS

X-Amz-Target

BODY json

{
  "name": "",
  "serviceName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstance");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\",\n  \"serviceName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstance" {:headers {:x-amz-target ""}
                                                                                               :content-type :json
                                                                                               :form-params {:name ""
                                                                                                             :serviceName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstance"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.GetServiceInstance"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"name\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.GetServiceInstance");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"serviceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstance"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"serviceName\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 37

{
  "name": "",
  "serviceName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstance")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"serviceName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstance"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"serviceName\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"serviceName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstance")
  .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=AwsProton20200720.GetServiceInstance")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"serviceName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  serviceName: ''
});

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=AwsProton20200720.GetServiceInstance');
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=AwsProton20200720.GetServiceInstance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: '', serviceName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstance';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":"","serviceName":""}'
};

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=AwsProton20200720.GetServiceInstance',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "serviceName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\",\n  \"serviceName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstance")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({name: '', serviceName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {name: '', serviceName: ''},
  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=AwsProton20200720.GetServiceInstance');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: '',
  serviceName: ''
});

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=AwsProton20200720.GetServiceInstance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: '', serviceName: ''}
};

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=AwsProton20200720.GetServiceInstance';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":"","serviceName":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"name": @"",
                              @"serviceName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstance"]
                                                       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=AwsProton20200720.GetServiceInstance" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\",\n  \"serviceName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstance",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => '',
    'serviceName' => ''
  ]),
  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=AwsProton20200720.GetServiceInstance', [
  'body' => '{
  "name": "",
  "serviceName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstance');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'serviceName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'name' => '',
  'serviceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstance');
$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=AwsProton20200720.GetServiceInstance' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "serviceName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstance' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "serviceName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"name\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.GetServiceInstance"

payload = {
    "name": "",
    "serviceName": ""
}
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=AwsProton20200720.GetServiceInstance"

payload <- "{\n  \"name\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.GetServiceInstance")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\",\n  \"serviceName\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"name\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.GetServiceInstance";

    let payload = json!({
        "name": "",
        "serviceName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstance' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "name": "",
  "serviceName": ""
}'

echo '{
  "name": "",
  "serviceName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstance' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": "",\n  "serviceName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstance'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "name": "",
  "serviceName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstance")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetServiceInstanceSyncStatus

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstanceSyncStatus

HEADERS

X-Amz-Target

BODY json

{
  "serviceInstanceName": "",
  "serviceName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstanceSyncStatus");

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  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstanceSyncStatus" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:serviceInstanceName ""
                                                                                                                       :serviceName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstanceSyncStatus"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.GetServiceInstanceSyncStatus"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.GetServiceInstanceSyncStatus");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstanceSyncStatus"

	payload := strings.NewReader("{\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 52

{
  "serviceInstanceName": "",
  "serviceName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstanceSyncStatus")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstanceSyncStatus"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstanceSyncStatus")
  .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=AwsProton20200720.GetServiceInstanceSyncStatus")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  serviceInstanceName: '',
  serviceName: ''
});

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=AwsProton20200720.GetServiceInstanceSyncStatus');
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=AwsProton20200720.GetServiceInstanceSyncStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {serviceInstanceName: '', serviceName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstanceSyncStatus';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"serviceInstanceName":"","serviceName":""}'
};

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=AwsProton20200720.GetServiceInstanceSyncStatus',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "serviceInstanceName": "",\n  "serviceName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstanceSyncStatus")
  .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({serviceInstanceName: '', serviceName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstanceSyncStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {serviceInstanceName: '', serviceName: ''},
  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=AwsProton20200720.GetServiceInstanceSyncStatus');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  serviceInstanceName: '',
  serviceName: ''
});

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=AwsProton20200720.GetServiceInstanceSyncStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {serviceInstanceName: '', serviceName: ''}
};

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=AwsProton20200720.GetServiceInstanceSyncStatus';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"serviceInstanceName":"","serviceName":""}'
};

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 = @{ @"serviceInstanceName": @"",
                              @"serviceName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstanceSyncStatus"]
                                                       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=AwsProton20200720.GetServiceInstanceSyncStatus" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstanceSyncStatus",
  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([
    'serviceInstanceName' => '',
    'serviceName' => ''
  ]),
  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=AwsProton20200720.GetServiceInstanceSyncStatus', [
  'body' => '{
  "serviceInstanceName": "",
  "serviceName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstanceSyncStatus');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'serviceInstanceName' => '',
  'serviceName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'serviceInstanceName' => '',
  'serviceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstanceSyncStatus');
$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=AwsProton20200720.GetServiceInstanceSyncStatus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "serviceInstanceName": "",
  "serviceName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstanceSyncStatus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "serviceInstanceName": "",
  "serviceName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.GetServiceInstanceSyncStatus"

payload = {
    "serviceInstanceName": "",
    "serviceName": ""
}
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=AwsProton20200720.GetServiceInstanceSyncStatus"

payload <- "{\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.GetServiceInstanceSyncStatus")

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  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.GetServiceInstanceSyncStatus";

    let payload = json!({
        "serviceInstanceName": "",
        "serviceName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstanceSyncStatus' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "serviceInstanceName": "",
  "serviceName": ""
}'

echo '{
  "serviceInstanceName": "",
  "serviceName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstanceSyncStatus' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "serviceInstanceName": "",\n  "serviceName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstanceSyncStatus'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "serviceInstanceName": "",
  "serviceName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceInstanceSyncStatus")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetServiceSyncBlockerSummary

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncBlockerSummary

HEADERS

X-Amz-Target

BODY json

{
  "serviceInstanceName": "",
  "serviceName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncBlockerSummary");

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  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncBlockerSummary" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:serviceInstanceName ""
                                                                                                                       :serviceName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncBlockerSummary"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.GetServiceSyncBlockerSummary"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.GetServiceSyncBlockerSummary");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncBlockerSummary"

	payload := strings.NewReader("{\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 52

{
  "serviceInstanceName": "",
  "serviceName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncBlockerSummary")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncBlockerSummary"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncBlockerSummary")
  .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=AwsProton20200720.GetServiceSyncBlockerSummary")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  serviceInstanceName: '',
  serviceName: ''
});

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=AwsProton20200720.GetServiceSyncBlockerSummary');
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=AwsProton20200720.GetServiceSyncBlockerSummary',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {serviceInstanceName: '', serviceName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncBlockerSummary';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"serviceInstanceName":"","serviceName":""}'
};

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=AwsProton20200720.GetServiceSyncBlockerSummary',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "serviceInstanceName": "",\n  "serviceName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncBlockerSummary")
  .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({serviceInstanceName: '', serviceName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncBlockerSummary',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {serviceInstanceName: '', serviceName: ''},
  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=AwsProton20200720.GetServiceSyncBlockerSummary');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  serviceInstanceName: '',
  serviceName: ''
});

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=AwsProton20200720.GetServiceSyncBlockerSummary',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {serviceInstanceName: '', serviceName: ''}
};

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=AwsProton20200720.GetServiceSyncBlockerSummary';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"serviceInstanceName":"","serviceName":""}'
};

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 = @{ @"serviceInstanceName": @"",
                              @"serviceName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncBlockerSummary"]
                                                       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=AwsProton20200720.GetServiceSyncBlockerSummary" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncBlockerSummary",
  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([
    'serviceInstanceName' => '',
    'serviceName' => ''
  ]),
  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=AwsProton20200720.GetServiceSyncBlockerSummary', [
  'body' => '{
  "serviceInstanceName": "",
  "serviceName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncBlockerSummary');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'serviceInstanceName' => '',
  'serviceName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'serviceInstanceName' => '',
  'serviceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncBlockerSummary');
$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=AwsProton20200720.GetServiceSyncBlockerSummary' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "serviceInstanceName": "",
  "serviceName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncBlockerSummary' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "serviceInstanceName": "",
  "serviceName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.GetServiceSyncBlockerSummary"

payload = {
    "serviceInstanceName": "",
    "serviceName": ""
}
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=AwsProton20200720.GetServiceSyncBlockerSummary"

payload <- "{\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.GetServiceSyncBlockerSummary")

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  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.GetServiceSyncBlockerSummary";

    let payload = json!({
        "serviceInstanceName": "",
        "serviceName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncBlockerSummary' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "serviceInstanceName": "",
  "serviceName": ""
}'

echo '{
  "serviceInstanceName": "",
  "serviceName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncBlockerSummary' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "serviceInstanceName": "",\n  "serviceName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncBlockerSummary'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "serviceInstanceName": "",
  "serviceName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncBlockerSummary")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetServiceSyncConfig

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncConfig

HEADERS

X-Amz-Target

BODY json

{
  "serviceName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncConfig");

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  \"serviceName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncConfig" {:headers {:x-amz-target ""}
                                                                                                 :content-type :json
                                                                                                 :form-params {:serviceName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncConfig"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"serviceName\": \"\"\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=AwsProton20200720.GetServiceSyncConfig"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"serviceName\": \"\"\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=AwsProton20200720.GetServiceSyncConfig");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"serviceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncConfig"

	payload := strings.NewReader("{\n  \"serviceName\": \"\"\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

{
  "serviceName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncConfig")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"serviceName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncConfig"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"serviceName\": \"\"\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  \"serviceName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncConfig")
  .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=AwsProton20200720.GetServiceSyncConfig")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"serviceName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  serviceName: ''
});

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=AwsProton20200720.GetServiceSyncConfig');
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=AwsProton20200720.GetServiceSyncConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {serviceName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"serviceName":""}'
};

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=AwsProton20200720.GetServiceSyncConfig',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "serviceName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"serviceName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncConfig")
  .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({serviceName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {serviceName: ''},
  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=AwsProton20200720.GetServiceSyncConfig');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  serviceName: ''
});

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=AwsProton20200720.GetServiceSyncConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {serviceName: ''}
};

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=AwsProton20200720.GetServiceSyncConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"serviceName":""}'
};

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 = @{ @"serviceName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncConfig"]
                                                       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=AwsProton20200720.GetServiceSyncConfig" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"serviceName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncConfig",
  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([
    'serviceName' => ''
  ]),
  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=AwsProton20200720.GetServiceSyncConfig', [
  'body' => '{
  "serviceName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncConfig');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'serviceName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'serviceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncConfig');
$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=AwsProton20200720.GetServiceSyncConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "serviceName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "serviceName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"serviceName\": \"\"\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=AwsProton20200720.GetServiceSyncConfig"

payload = { "serviceName": "" }
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=AwsProton20200720.GetServiceSyncConfig"

payload <- "{\n  \"serviceName\": \"\"\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=AwsProton20200720.GetServiceSyncConfig")

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  \"serviceName\": \"\"\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  \"serviceName\": \"\"\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=AwsProton20200720.GetServiceSyncConfig";

    let payload = json!({"serviceName": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncConfig' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "serviceName": ""
}'

echo '{
  "serviceName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncConfig' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "serviceName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncConfig'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["serviceName": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceSyncConfig")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetServiceTemplate

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate

HEADERS

X-Amz-Target

BODY json

{
  "name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate" {:headers {:x-amz-target ""}
                                                                                               :content-type :json
                                                                                               :form-params {:name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate"

	payload := strings.NewReader("{\n  \"name\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 16

{
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate")
  .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=AwsProton20200720.GetServiceTemplate")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate');
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=AwsProton20200720.GetServiceTemplate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate"]
                                                       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=AwsProton20200720.GetServiceTemplate" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate', [
  'body' => '{
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate');
$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=AwsProton20200720.GetServiceTemplate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"name\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate"

payload = { "name": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate"

payload <- "{\n  \"name\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"name\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate";

    let payload = json!({"name": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "name": ""
}'

echo '{
  "name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["name": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetServiceTemplateVersion

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplateVersion

HEADERS

X-Amz-Target

BODY json

{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplateVersion");

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  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplateVersion" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:majorVersion ""
                                                                                                                    :minorVersion ""
                                                                                                                    :templateName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplateVersion"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.GetServiceTemplateVersion"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.GetServiceTemplateVersion");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplateVersion"

	payload := strings.NewReader("{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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: 68

{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplateVersion")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplateVersion"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplateVersion")
  .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=AwsProton20200720.GetServiceTemplateVersion")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  majorVersion: '',
  minorVersion: '',
  templateName: ''
});

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=AwsProton20200720.GetServiceTemplateVersion');
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=AwsProton20200720.GetServiceTemplateVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {majorVersion: '', minorVersion: '', templateName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplateVersion';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"majorVersion":"","minorVersion":"","templateName":""}'
};

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=AwsProton20200720.GetServiceTemplateVersion',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "majorVersion": "",\n  "minorVersion": "",\n  "templateName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplateVersion")
  .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({majorVersion: '', minorVersion: '', templateName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplateVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {majorVersion: '', minorVersion: '', templateName: ''},
  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=AwsProton20200720.GetServiceTemplateVersion');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  majorVersion: '',
  minorVersion: '',
  templateName: ''
});

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=AwsProton20200720.GetServiceTemplateVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {majorVersion: '', minorVersion: '', templateName: ''}
};

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=AwsProton20200720.GetServiceTemplateVersion';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"majorVersion":"","minorVersion":"","templateName":""}'
};

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 = @{ @"majorVersion": @"",
                              @"minorVersion": @"",
                              @"templateName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplateVersion"]
                                                       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=AwsProton20200720.GetServiceTemplateVersion" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplateVersion",
  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([
    'majorVersion' => '',
    'minorVersion' => '',
    'templateName' => ''
  ]),
  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=AwsProton20200720.GetServiceTemplateVersion', [
  'body' => '{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplateVersion');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'majorVersion' => '',
  'minorVersion' => '',
  'templateName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'majorVersion' => '',
  'minorVersion' => '',
  'templateName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplateVersion');
$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=AwsProton20200720.GetServiceTemplateVersion' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplateVersion' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.GetServiceTemplateVersion"

payload = {
    "majorVersion": "",
    "minorVersion": "",
    "templateName": ""
}
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=AwsProton20200720.GetServiceTemplateVersion"

payload <- "{\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.GetServiceTemplateVersion")

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  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.GetServiceTemplateVersion";

    let payload = json!({
        "majorVersion": "",
        "minorVersion": "",
        "templateName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplateVersion' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}'

echo '{
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplateVersion' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "majorVersion": "",\n  "minorVersion": "",\n  "templateName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplateVersion'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "majorVersion": "",
  "minorVersion": "",
  "templateName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetServiceTemplateVersion")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetTemplateSyncConfig

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncConfig

HEADERS

X-Amz-Target

BODY json

{
  "templateName": "",
  "templateType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncConfig");

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  \"templateName\": \"\",\n  \"templateType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncConfig" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:templateName ""
                                                                                                                :templateType ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncConfig"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"templateName\": \"\",\n  \"templateType\": \"\"\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=AwsProton20200720.GetTemplateSyncConfig"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"templateName\": \"\",\n  \"templateType\": \"\"\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=AwsProton20200720.GetTemplateSyncConfig");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"templateName\": \"\",\n  \"templateType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncConfig"

	payload := strings.NewReader("{\n  \"templateName\": \"\",\n  \"templateType\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 46

{
  "templateName": "",
  "templateType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncConfig")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"templateName\": \"\",\n  \"templateType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncConfig"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"templateName\": \"\",\n  \"templateType\": \"\"\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  \"templateName\": \"\",\n  \"templateType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncConfig")
  .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=AwsProton20200720.GetTemplateSyncConfig")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"templateName\": \"\",\n  \"templateType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  templateName: '',
  templateType: ''
});

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=AwsProton20200720.GetTemplateSyncConfig');
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=AwsProton20200720.GetTemplateSyncConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {templateName: '', templateType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"templateName":"","templateType":""}'
};

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=AwsProton20200720.GetTemplateSyncConfig',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "templateName": "",\n  "templateType": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"templateName\": \"\",\n  \"templateType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncConfig")
  .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({templateName: '', templateType: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {templateName: '', templateType: ''},
  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=AwsProton20200720.GetTemplateSyncConfig');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  templateName: '',
  templateType: ''
});

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=AwsProton20200720.GetTemplateSyncConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {templateName: '', templateType: ''}
};

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=AwsProton20200720.GetTemplateSyncConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"templateName":"","templateType":""}'
};

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 = @{ @"templateName": @"",
                              @"templateType": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncConfig"]
                                                       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=AwsProton20200720.GetTemplateSyncConfig" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"templateName\": \"\",\n  \"templateType\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncConfig",
  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([
    'templateName' => '',
    'templateType' => ''
  ]),
  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=AwsProton20200720.GetTemplateSyncConfig', [
  'body' => '{
  "templateName": "",
  "templateType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncConfig');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'templateName' => '',
  'templateType' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'templateName' => '',
  'templateType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncConfig');
$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=AwsProton20200720.GetTemplateSyncConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "templateName": "",
  "templateType": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "templateName": "",
  "templateType": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"templateName\": \"\",\n  \"templateType\": \"\"\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=AwsProton20200720.GetTemplateSyncConfig"

payload = {
    "templateName": "",
    "templateType": ""
}
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=AwsProton20200720.GetTemplateSyncConfig"

payload <- "{\n  \"templateName\": \"\",\n  \"templateType\": \"\"\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=AwsProton20200720.GetTemplateSyncConfig")

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  \"templateName\": \"\",\n  \"templateType\": \"\"\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  \"templateName\": \"\",\n  \"templateType\": \"\"\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=AwsProton20200720.GetTemplateSyncConfig";

    let payload = json!({
        "templateName": "",
        "templateType": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncConfig' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "templateName": "",
  "templateType": ""
}'

echo '{
  "templateName": "",
  "templateType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncConfig' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "templateName": "",\n  "templateType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncConfig'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "templateName": "",
  "templateType": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncConfig")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST GetTemplateSyncStatus

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncStatus

HEADERS

X-Amz-Target

BODY json

{
  "templateName": "",
  "templateType": "",
  "templateVersion": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncStatus");

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  \"templateName\": \"\",\n  \"templateType\": \"\",\n  \"templateVersion\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncStatus" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:templateName ""
                                                                                                                :templateType ""
                                                                                                                :templateVersion ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncStatus"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"templateName\": \"\",\n  \"templateType\": \"\",\n  \"templateVersion\": \"\"\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=AwsProton20200720.GetTemplateSyncStatus"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"templateName\": \"\",\n  \"templateType\": \"\",\n  \"templateVersion\": \"\"\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=AwsProton20200720.GetTemplateSyncStatus");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"templateName\": \"\",\n  \"templateType\": \"\",\n  \"templateVersion\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncStatus"

	payload := strings.NewReader("{\n  \"templateName\": \"\",\n  \"templateType\": \"\",\n  \"templateVersion\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 71

{
  "templateName": "",
  "templateType": "",
  "templateVersion": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncStatus")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"templateName\": \"\",\n  \"templateType\": \"\",\n  \"templateVersion\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncStatus"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"templateName\": \"\",\n  \"templateType\": \"\",\n  \"templateVersion\": \"\"\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  \"templateName\": \"\",\n  \"templateType\": \"\",\n  \"templateVersion\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncStatus")
  .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=AwsProton20200720.GetTemplateSyncStatus")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"templateName\": \"\",\n  \"templateType\": \"\",\n  \"templateVersion\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  templateName: '',
  templateType: '',
  templateVersion: ''
});

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=AwsProton20200720.GetTemplateSyncStatus');
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=AwsProton20200720.GetTemplateSyncStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {templateName: '', templateType: '', templateVersion: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncStatus';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"templateName":"","templateType":"","templateVersion":""}'
};

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=AwsProton20200720.GetTemplateSyncStatus',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "templateName": "",\n  "templateType": "",\n  "templateVersion": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"templateName\": \"\",\n  \"templateType\": \"\",\n  \"templateVersion\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncStatus")
  .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({templateName: '', templateType: '', templateVersion: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {templateName: '', templateType: '', templateVersion: ''},
  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=AwsProton20200720.GetTemplateSyncStatus');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  templateName: '',
  templateType: '',
  templateVersion: ''
});

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=AwsProton20200720.GetTemplateSyncStatus',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {templateName: '', templateType: '', templateVersion: ''}
};

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=AwsProton20200720.GetTemplateSyncStatus';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"templateName":"","templateType":"","templateVersion":""}'
};

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 = @{ @"templateName": @"",
                              @"templateType": @"",
                              @"templateVersion": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncStatus"]
                                                       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=AwsProton20200720.GetTemplateSyncStatus" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"templateName\": \"\",\n  \"templateType\": \"\",\n  \"templateVersion\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncStatus",
  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([
    'templateName' => '',
    'templateType' => '',
    'templateVersion' => ''
  ]),
  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=AwsProton20200720.GetTemplateSyncStatus', [
  'body' => '{
  "templateName": "",
  "templateType": "",
  "templateVersion": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncStatus');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'templateName' => '',
  'templateType' => '',
  'templateVersion' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'templateName' => '',
  'templateType' => '',
  'templateVersion' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncStatus');
$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=AwsProton20200720.GetTemplateSyncStatus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "templateName": "",
  "templateType": "",
  "templateVersion": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncStatus' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "templateName": "",
  "templateType": "",
  "templateVersion": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"templateName\": \"\",\n  \"templateType\": \"\",\n  \"templateVersion\": \"\"\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=AwsProton20200720.GetTemplateSyncStatus"

payload = {
    "templateName": "",
    "templateType": "",
    "templateVersion": ""
}
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=AwsProton20200720.GetTemplateSyncStatus"

payload <- "{\n  \"templateName\": \"\",\n  \"templateType\": \"\",\n  \"templateVersion\": \"\"\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=AwsProton20200720.GetTemplateSyncStatus")

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  \"templateName\": \"\",\n  \"templateType\": \"\",\n  \"templateVersion\": \"\"\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  \"templateName\": \"\",\n  \"templateType\": \"\",\n  \"templateVersion\": \"\"\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=AwsProton20200720.GetTemplateSyncStatus";

    let payload = json!({
        "templateName": "",
        "templateType": "",
        "templateVersion": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncStatus' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "templateName": "",
  "templateType": "",
  "templateVersion": ""
}'

echo '{
  "templateName": "",
  "templateType": "",
  "templateVersion": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncStatus' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "templateName": "",\n  "templateType": "",\n  "templateVersion": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncStatus'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "templateName": "",
  "templateType": "",
  "templateVersion": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.GetTemplateSyncStatus")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListComponentOutputs

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs

HEADERS

X-Amz-Target

BODY json

{
  "componentName": "",
  "nextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs");

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  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs" {:headers {:x-amz-target ""}
                                                                                                 :content-type :json
                                                                                                 :form-params {:componentName ""
                                                                                                               :nextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs"

	payload := strings.NewReader("{\n  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 44

{
  "componentName": "",
  "nextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs")
  .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=AwsProton20200720.ListComponentOutputs")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  componentName: '',
  nextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs');
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=AwsProton20200720.ListComponentOutputs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {componentName: '', nextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"componentName":"","nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "componentName": "",\n  "nextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs")
  .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({componentName: '', nextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {componentName: '', nextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  componentName: '',
  nextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {componentName: '', nextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"componentName":"","nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"componentName": @"",
                              @"nextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs"]
                                                       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=AwsProton20200720.ListComponentOutputs" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs",
  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([
    'componentName' => '',
    'nextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs', [
  'body' => '{
  "componentName": "",
  "nextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'componentName' => '',
  'nextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'componentName' => '',
  'nextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs');
$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=AwsProton20200720.ListComponentOutputs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "componentName": "",
  "nextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "componentName": "",
  "nextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs"

payload = {
    "componentName": "",
    "nextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs"

payload <- "{\n  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs")

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  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs";

    let payload = json!({
        "componentName": "",
        "nextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "componentName": "",
  "nextToken": ""
}'

echo '{
  "componentName": "",
  "nextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "componentName": "",\n  "nextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "componentName": "",
  "nextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentOutputs")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListComponentProvisionedResources

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources

HEADERS

X-Amz-Target

BODY json

{
  "componentName": "",
  "nextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources");

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  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources" {:headers {:x-amz-target ""}
                                                                                                              :content-type :json
                                                                                                              :form-params {:componentName ""
                                                                                                                            :nextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources"

	payload := strings.NewReader("{\n  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 44

{
  "componentName": "",
  "nextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources")
  .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=AwsProton20200720.ListComponentProvisionedResources")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  componentName: '',
  nextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources');
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=AwsProton20200720.ListComponentProvisionedResources',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {componentName: '', nextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"componentName":"","nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "componentName": "",\n  "nextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources")
  .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({componentName: '', nextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {componentName: '', nextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  componentName: '',
  nextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {componentName: '', nextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"componentName":"","nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"componentName": @"",
                              @"nextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources"]
                                                       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=AwsProton20200720.ListComponentProvisionedResources" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources",
  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([
    'componentName' => '',
    'nextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources', [
  'body' => '{
  "componentName": "",
  "nextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'componentName' => '',
  'nextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'componentName' => '',
  'nextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources');
$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=AwsProton20200720.ListComponentProvisionedResources' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "componentName": "",
  "nextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "componentName": "",
  "nextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources"

payload = {
    "componentName": "",
    "nextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources"

payload <- "{\n  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources")

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  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"componentName\": \"\",\n  \"nextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources";

    let payload = json!({
        "componentName": "",
        "nextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "componentName": "",
  "nextToken": ""
}'

echo '{
  "componentName": "",
  "nextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "componentName": "",\n  "nextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "componentName": "",
  "nextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponentProvisionedResources")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListComponents

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponents

HEADERS

X-Amz-Target

BODY json

{
  "environmentName": "",
  "maxResults": "",
  "nextToken": "",
  "serviceInstanceName": "",
  "serviceName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponents");

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  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponents" {:headers {:x-amz-target ""}
                                                                                           :content-type :json
                                                                                           :form-params {:environmentName ""
                                                                                                         :maxResults ""
                                                                                                         :nextToken ""
                                                                                                         :serviceInstanceName ""
                                                                                                         :serviceName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponents"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.ListComponents"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.ListComponents");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponents"

	payload := strings.NewReader("{\n  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 116

{
  "environmentName": "",
  "maxResults": "",
  "nextToken": "",
  "serviceInstanceName": "",
  "serviceName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponents")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponents"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponents")
  .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=AwsProton20200720.ListComponents")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  environmentName: '',
  maxResults: '',
  nextToken: '',
  serviceInstanceName: '',
  serviceName: ''
});

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=AwsProton20200720.ListComponents');
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=AwsProton20200720.ListComponents',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    environmentName: '',
    maxResults: '',
    nextToken: '',
    serviceInstanceName: '',
    serviceName: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponents';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"environmentName":"","maxResults":"","nextToken":"","serviceInstanceName":"","serviceName":""}'
};

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=AwsProton20200720.ListComponents',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "environmentName": "",\n  "maxResults": "",\n  "nextToken": "",\n  "serviceInstanceName": "",\n  "serviceName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponents")
  .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({
  environmentName: '',
  maxResults: '',
  nextToken: '',
  serviceInstanceName: '',
  serviceName: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponents',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    environmentName: '',
    maxResults: '',
    nextToken: '',
    serviceInstanceName: '',
    serviceName: ''
  },
  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=AwsProton20200720.ListComponents');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  environmentName: '',
  maxResults: '',
  nextToken: '',
  serviceInstanceName: '',
  serviceName: ''
});

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=AwsProton20200720.ListComponents',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    environmentName: '',
    maxResults: '',
    nextToken: '',
    serviceInstanceName: '',
    serviceName: ''
  }
};

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=AwsProton20200720.ListComponents';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"environmentName":"","maxResults":"","nextToken":"","serviceInstanceName":"","serviceName":""}'
};

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 = @{ @"environmentName": @"",
                              @"maxResults": @"",
                              @"nextToken": @"",
                              @"serviceInstanceName": @"",
                              @"serviceName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponents"]
                                                       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=AwsProton20200720.ListComponents" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponents",
  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([
    'environmentName' => '',
    'maxResults' => '',
    'nextToken' => '',
    'serviceInstanceName' => '',
    'serviceName' => ''
  ]),
  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=AwsProton20200720.ListComponents', [
  'body' => '{
  "environmentName": "",
  "maxResults": "",
  "nextToken": "",
  "serviceInstanceName": "",
  "serviceName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponents');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'environmentName' => '',
  'maxResults' => '',
  'nextToken' => '',
  'serviceInstanceName' => '',
  'serviceName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'environmentName' => '',
  'maxResults' => '',
  'nextToken' => '',
  'serviceInstanceName' => '',
  'serviceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponents');
$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=AwsProton20200720.ListComponents' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "environmentName": "",
  "maxResults": "",
  "nextToken": "",
  "serviceInstanceName": "",
  "serviceName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponents' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "environmentName": "",
  "maxResults": "",
  "nextToken": "",
  "serviceInstanceName": "",
  "serviceName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.ListComponents"

payload = {
    "environmentName": "",
    "maxResults": "",
    "nextToken": "",
    "serviceInstanceName": "",
    "serviceName": ""
}
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=AwsProton20200720.ListComponents"

payload <- "{\n  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.ListComponents")

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  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.ListComponents";

    let payload = json!({
        "environmentName": "",
        "maxResults": "",
        "nextToken": "",
        "serviceInstanceName": "",
        "serviceName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponents' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "environmentName": "",
  "maxResults": "",
  "nextToken": "",
  "serviceInstanceName": "",
  "serviceName": ""
}'

echo '{
  "environmentName": "",
  "maxResults": "",
  "nextToken": "",
  "serviceInstanceName": "",
  "serviceName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponents' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "environmentName": "",\n  "maxResults": "",\n  "nextToken": "",\n  "serviceInstanceName": "",\n  "serviceName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponents'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "environmentName": "",
  "maxResults": "",
  "nextToken": "",
  "serviceInstanceName": "",
  "serviceName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListComponents")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListEnvironmentAccountConnections

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentAccountConnections

HEADERS

X-Amz-Target

BODY json

{
  "environmentName": "",
  "maxResults": "",
  "nextToken": "",
  "requestedBy": "",
  "statuses": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentAccountConnections");

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  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"requestedBy\": \"\",\n  \"statuses\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentAccountConnections" {:headers {:x-amz-target ""}
                                                                                                              :content-type :json
                                                                                                              :form-params {:environmentName ""
                                                                                                                            :maxResults ""
                                                                                                                            :nextToken ""
                                                                                                                            :requestedBy ""
                                                                                                                            :statuses ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentAccountConnections"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"requestedBy\": \"\",\n  \"statuses\": \"\"\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=AwsProton20200720.ListEnvironmentAccountConnections"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"requestedBy\": \"\",\n  \"statuses\": \"\"\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=AwsProton20200720.ListEnvironmentAccountConnections");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"requestedBy\": \"\",\n  \"statuses\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentAccountConnections"

	payload := strings.NewReader("{\n  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"requestedBy\": \"\",\n  \"statuses\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 105

{
  "environmentName": "",
  "maxResults": "",
  "nextToken": "",
  "requestedBy": "",
  "statuses": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentAccountConnections")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"requestedBy\": \"\",\n  \"statuses\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentAccountConnections"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"requestedBy\": \"\",\n  \"statuses\": \"\"\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  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"requestedBy\": \"\",\n  \"statuses\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentAccountConnections")
  .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=AwsProton20200720.ListEnvironmentAccountConnections")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"requestedBy\": \"\",\n  \"statuses\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  environmentName: '',
  maxResults: '',
  nextToken: '',
  requestedBy: '',
  statuses: ''
});

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=AwsProton20200720.ListEnvironmentAccountConnections');
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=AwsProton20200720.ListEnvironmentAccountConnections',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    environmentName: '',
    maxResults: '',
    nextToken: '',
    requestedBy: '',
    statuses: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentAccountConnections';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"environmentName":"","maxResults":"","nextToken":"","requestedBy":"","statuses":""}'
};

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=AwsProton20200720.ListEnvironmentAccountConnections',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "environmentName": "",\n  "maxResults": "",\n  "nextToken": "",\n  "requestedBy": "",\n  "statuses": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"requestedBy\": \"\",\n  \"statuses\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentAccountConnections")
  .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({
  environmentName: '',
  maxResults: '',
  nextToken: '',
  requestedBy: '',
  statuses: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentAccountConnections',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    environmentName: '',
    maxResults: '',
    nextToken: '',
    requestedBy: '',
    statuses: ''
  },
  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=AwsProton20200720.ListEnvironmentAccountConnections');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  environmentName: '',
  maxResults: '',
  nextToken: '',
  requestedBy: '',
  statuses: ''
});

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=AwsProton20200720.ListEnvironmentAccountConnections',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    environmentName: '',
    maxResults: '',
    nextToken: '',
    requestedBy: '',
    statuses: ''
  }
};

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=AwsProton20200720.ListEnvironmentAccountConnections';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"environmentName":"","maxResults":"","nextToken":"","requestedBy":"","statuses":""}'
};

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 = @{ @"environmentName": @"",
                              @"maxResults": @"",
                              @"nextToken": @"",
                              @"requestedBy": @"",
                              @"statuses": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentAccountConnections"]
                                                       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=AwsProton20200720.ListEnvironmentAccountConnections" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"requestedBy\": \"\",\n  \"statuses\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentAccountConnections",
  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([
    'environmentName' => '',
    'maxResults' => '',
    'nextToken' => '',
    'requestedBy' => '',
    'statuses' => ''
  ]),
  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=AwsProton20200720.ListEnvironmentAccountConnections', [
  'body' => '{
  "environmentName": "",
  "maxResults": "",
  "nextToken": "",
  "requestedBy": "",
  "statuses": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentAccountConnections');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'environmentName' => '',
  'maxResults' => '',
  'nextToken' => '',
  'requestedBy' => '',
  'statuses' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'environmentName' => '',
  'maxResults' => '',
  'nextToken' => '',
  'requestedBy' => '',
  'statuses' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentAccountConnections');
$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=AwsProton20200720.ListEnvironmentAccountConnections' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "environmentName": "",
  "maxResults": "",
  "nextToken": "",
  "requestedBy": "",
  "statuses": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentAccountConnections' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "environmentName": "",
  "maxResults": "",
  "nextToken": "",
  "requestedBy": "",
  "statuses": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"requestedBy\": \"\",\n  \"statuses\": \"\"\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=AwsProton20200720.ListEnvironmentAccountConnections"

payload = {
    "environmentName": "",
    "maxResults": "",
    "nextToken": "",
    "requestedBy": "",
    "statuses": ""
}
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=AwsProton20200720.ListEnvironmentAccountConnections"

payload <- "{\n  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"requestedBy\": \"\",\n  \"statuses\": \"\"\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=AwsProton20200720.ListEnvironmentAccountConnections")

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  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"requestedBy\": \"\",\n  \"statuses\": \"\"\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  \"environmentName\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"requestedBy\": \"\",\n  \"statuses\": \"\"\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=AwsProton20200720.ListEnvironmentAccountConnections";

    let payload = json!({
        "environmentName": "",
        "maxResults": "",
        "nextToken": "",
        "requestedBy": "",
        "statuses": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentAccountConnections' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "environmentName": "",
  "maxResults": "",
  "nextToken": "",
  "requestedBy": "",
  "statuses": ""
}'

echo '{
  "environmentName": "",
  "maxResults": "",
  "nextToken": "",
  "requestedBy": "",
  "statuses": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentAccountConnections' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "environmentName": "",\n  "maxResults": "",\n  "nextToken": "",\n  "requestedBy": "",\n  "statuses": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentAccountConnections'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "environmentName": "",
  "maxResults": "",
  "nextToken": "",
  "requestedBy": "",
  "statuses": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentAccountConnections")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListEnvironmentOutputs

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs

HEADERS

X-Amz-Target

BODY json

{
  "environmentName": "",
  "nextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs");

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  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs" {:headers {:x-amz-target ""}
                                                                                                   :content-type :json
                                                                                                   :form-params {:environmentName ""
                                                                                                                 :nextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs"

	payload := strings.NewReader("{\n  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 46

{
  "environmentName": "",
  "nextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs")
  .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=AwsProton20200720.ListEnvironmentOutputs")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  environmentName: '',
  nextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs');
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=AwsProton20200720.ListEnvironmentOutputs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {environmentName: '', nextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"environmentName":"","nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "environmentName": "",\n  "nextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs")
  .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({environmentName: '', nextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {environmentName: '', nextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  environmentName: '',
  nextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {environmentName: '', nextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"environmentName":"","nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"environmentName": @"",
                              @"nextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs"]
                                                       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=AwsProton20200720.ListEnvironmentOutputs" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs",
  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([
    'environmentName' => '',
    'nextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs', [
  'body' => '{
  "environmentName": "",
  "nextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'environmentName' => '',
  'nextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'environmentName' => '',
  'nextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs');
$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=AwsProton20200720.ListEnvironmentOutputs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "environmentName": "",
  "nextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "environmentName": "",
  "nextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs"

payload = {
    "environmentName": "",
    "nextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs"

payload <- "{\n  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs")

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  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs";

    let payload = json!({
        "environmentName": "",
        "nextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "environmentName": "",
  "nextToken": ""
}'

echo '{
  "environmentName": "",
  "nextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "environmentName": "",\n  "nextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "environmentName": "",
  "nextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentOutputs")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListEnvironmentProvisionedResources

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources

HEADERS

X-Amz-Target

BODY json

{
  "environmentName": "",
  "nextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources");

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  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources" {:headers {:x-amz-target ""}
                                                                                                                :content-type :json
                                                                                                                :form-params {:environmentName ""
                                                                                                                              :nextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources"

	payload := strings.NewReader("{\n  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 46

{
  "environmentName": "",
  "nextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources")
  .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=AwsProton20200720.ListEnvironmentProvisionedResources")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  environmentName: '',
  nextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources');
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=AwsProton20200720.ListEnvironmentProvisionedResources',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {environmentName: '', nextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"environmentName":"","nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "environmentName": "",\n  "nextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources")
  .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({environmentName: '', nextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {environmentName: '', nextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  environmentName: '',
  nextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {environmentName: '', nextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"environmentName":"","nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"environmentName": @"",
                              @"nextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources"]
                                                       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=AwsProton20200720.ListEnvironmentProvisionedResources" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources",
  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([
    'environmentName' => '',
    'nextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources', [
  'body' => '{
  "environmentName": "",
  "nextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'environmentName' => '',
  'nextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'environmentName' => '',
  'nextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources');
$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=AwsProton20200720.ListEnvironmentProvisionedResources' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "environmentName": "",
  "nextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "environmentName": "",
  "nextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources"

payload = {
    "environmentName": "",
    "nextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources"

payload <- "{\n  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources")

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  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"environmentName\": \"\",\n  \"nextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources";

    let payload = json!({
        "environmentName": "",
        "nextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "environmentName": "",
  "nextToken": ""
}'

echo '{
  "environmentName": "",
  "nextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "environmentName": "",\n  "nextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "environmentName": "",
  "nextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentProvisionedResources")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListEnvironmentTemplateVersions

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplateVersions

HEADERS

X-Amz-Target

BODY json

{
  "majorVersion": "",
  "maxResults": "",
  "nextToken": "",
  "templateName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplateVersions");

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  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplateVersions" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:majorVersion ""
                                                                                                                          :maxResults ""
                                                                                                                          :nextToken ""
                                                                                                                          :templateName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplateVersions"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.ListEnvironmentTemplateVersions"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.ListEnvironmentTemplateVersions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplateVersions"

	payload := strings.NewReader("{\n  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\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: 85

{
  "majorVersion": "",
  "maxResults": "",
  "nextToken": "",
  "templateName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplateVersions")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplateVersions"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\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  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplateVersions")
  .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=AwsProton20200720.ListEnvironmentTemplateVersions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  majorVersion: '',
  maxResults: '',
  nextToken: '',
  templateName: ''
});

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=AwsProton20200720.ListEnvironmentTemplateVersions');
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=AwsProton20200720.ListEnvironmentTemplateVersions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {majorVersion: '', maxResults: '', nextToken: '', templateName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplateVersions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"majorVersion":"","maxResults":"","nextToken":"","templateName":""}'
};

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=AwsProton20200720.ListEnvironmentTemplateVersions',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "majorVersion": "",\n  "maxResults": "",\n  "nextToken": "",\n  "templateName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplateVersions")
  .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({majorVersion: '', maxResults: '', nextToken: '', templateName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplateVersions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {majorVersion: '', maxResults: '', nextToken: '', templateName: ''},
  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=AwsProton20200720.ListEnvironmentTemplateVersions');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  majorVersion: '',
  maxResults: '',
  nextToken: '',
  templateName: ''
});

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=AwsProton20200720.ListEnvironmentTemplateVersions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {majorVersion: '', maxResults: '', nextToken: '', templateName: ''}
};

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=AwsProton20200720.ListEnvironmentTemplateVersions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"majorVersion":"","maxResults":"","nextToken":"","templateName":""}'
};

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 = @{ @"majorVersion": @"",
                              @"maxResults": @"",
                              @"nextToken": @"",
                              @"templateName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplateVersions"]
                                                       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=AwsProton20200720.ListEnvironmentTemplateVersions" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplateVersions",
  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([
    'majorVersion' => '',
    'maxResults' => '',
    'nextToken' => '',
    'templateName' => ''
  ]),
  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=AwsProton20200720.ListEnvironmentTemplateVersions', [
  'body' => '{
  "majorVersion": "",
  "maxResults": "",
  "nextToken": "",
  "templateName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplateVersions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'majorVersion' => '',
  'maxResults' => '',
  'nextToken' => '',
  'templateName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'majorVersion' => '',
  'maxResults' => '',
  'nextToken' => '',
  'templateName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplateVersions');
$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=AwsProton20200720.ListEnvironmentTemplateVersions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "majorVersion": "",
  "maxResults": "",
  "nextToken": "",
  "templateName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplateVersions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "majorVersion": "",
  "maxResults": "",
  "nextToken": "",
  "templateName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.ListEnvironmentTemplateVersions"

payload = {
    "majorVersion": "",
    "maxResults": "",
    "nextToken": "",
    "templateName": ""
}
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=AwsProton20200720.ListEnvironmentTemplateVersions"

payload <- "{\n  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.ListEnvironmentTemplateVersions")

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  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\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  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.ListEnvironmentTemplateVersions";

    let payload = json!({
        "majorVersion": "",
        "maxResults": "",
        "nextToken": "",
        "templateName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplateVersions' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "majorVersion": "",
  "maxResults": "",
  "nextToken": "",
  "templateName": ""
}'

echo '{
  "majorVersion": "",
  "maxResults": "",
  "nextToken": "",
  "templateName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplateVersions' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "majorVersion": "",\n  "maxResults": "",\n  "nextToken": "",\n  "templateName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplateVersions'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "majorVersion": "",
  "maxResults": "",
  "nextToken": "",
  "templateName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplateVersions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListEnvironmentTemplates

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates

HEADERS

X-Amz-Target

BODY json

{
  "maxResults": "",
  "nextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:maxResults ""
                                                                                                                   :nextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates"

	payload := strings.NewReader("{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 41

{
  "maxResults": "",
  "nextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates")
  .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=AwsProton20200720.ListEnvironmentTemplates")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  maxResults: '',
  nextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates');
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=AwsProton20200720.ListEnvironmentTemplates',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {maxResults: '', nextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"maxResults":"","nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "maxResults": "",\n  "nextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({maxResults: '', nextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {maxResults: '', nextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  maxResults: '',
  nextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {maxResults: '', nextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"maxResults":"","nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"maxResults": @"",
                              @"nextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates"]
                                                       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=AwsProton20200720.ListEnvironmentTemplates" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'maxResults' => '',
    'nextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates', [
  'body' => '{
  "maxResults": "",
  "nextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'maxResults' => '',
  'nextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'maxResults' => '',
  'nextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates');
$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=AwsProton20200720.ListEnvironmentTemplates' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "maxResults": "",
  "nextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "maxResults": "",
  "nextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates"

payload = {
    "maxResults": "",
    "nextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates"

payload <- "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates";

    let payload = json!({
        "maxResults": "",
        "nextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "maxResults": "",
  "nextToken": ""
}'

echo '{
  "maxResults": "",
  "nextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "maxResults": "",\n  "nextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "maxResults": "",
  "nextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironmentTemplates")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListEnvironments

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments

HEADERS

X-Amz-Target

BODY json

{
  "environmentTemplates": "",
  "maxResults": "",
  "nextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments");

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  \"environmentTemplates\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments" {:headers {:x-amz-target ""}
                                                                                             :content-type :json
                                                                                             :form-params {:environmentTemplates ""
                                                                                                           :maxResults ""
                                                                                                           :nextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"environmentTemplates\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"environmentTemplates\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"environmentTemplates\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments"

	payload := strings.NewReader("{\n  \"environmentTemplates\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 71

{
  "environmentTemplates": "",
  "maxResults": "",
  "nextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"environmentTemplates\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"environmentTemplates\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"environmentTemplates\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments")
  .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=AwsProton20200720.ListEnvironments")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"environmentTemplates\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  environmentTemplates: '',
  maxResults: '',
  nextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments');
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=AwsProton20200720.ListEnvironments',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {environmentTemplates: '', maxResults: '', nextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"environmentTemplates":"","maxResults":"","nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "environmentTemplates": "",\n  "maxResults": "",\n  "nextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"environmentTemplates\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments")
  .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({environmentTemplates: '', maxResults: '', nextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {environmentTemplates: '', maxResults: '', nextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  environmentTemplates: '',
  maxResults: '',
  nextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {environmentTemplates: '', maxResults: '', nextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"environmentTemplates":"","maxResults":"","nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"environmentTemplates": @"",
                              @"maxResults": @"",
                              @"nextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments"]
                                                       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=AwsProton20200720.ListEnvironments" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"environmentTemplates\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments",
  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([
    'environmentTemplates' => '',
    'maxResults' => '',
    'nextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments', [
  'body' => '{
  "environmentTemplates": "",
  "maxResults": "",
  "nextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'environmentTemplates' => '',
  'maxResults' => '',
  'nextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'environmentTemplates' => '',
  'maxResults' => '',
  'nextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments');
$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=AwsProton20200720.ListEnvironments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "environmentTemplates": "",
  "maxResults": "",
  "nextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "environmentTemplates": "",
  "maxResults": "",
  "nextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"environmentTemplates\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments"

payload = {
    "environmentTemplates": "",
    "maxResults": "",
    "nextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments"

payload <- "{\n  \"environmentTemplates\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments")

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  \"environmentTemplates\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"environmentTemplates\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments";

    let payload = json!({
        "environmentTemplates": "",
        "maxResults": "",
        "nextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "environmentTemplates": "",
  "maxResults": "",
  "nextToken": ""
}'

echo '{
  "environmentTemplates": "",
  "maxResults": "",
  "nextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "environmentTemplates": "",\n  "maxResults": "",\n  "nextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "environmentTemplates": "",
  "maxResults": "",
  "nextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListEnvironments")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListRepositories

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories

HEADERS

X-Amz-Target

BODY json

{
  "maxResults": "",
  "nextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories" {:headers {:x-amz-target ""}
                                                                                             :content-type :json
                                                                                             :form-params {:maxResults ""
                                                                                                           :nextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories"

	payload := strings.NewReader("{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 41

{
  "maxResults": "",
  "nextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories")
  .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=AwsProton20200720.ListRepositories")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  maxResults: '',
  nextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories');
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=AwsProton20200720.ListRepositories',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {maxResults: '', nextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"maxResults":"","nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "maxResults": "",\n  "nextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({maxResults: '', nextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {maxResults: '', nextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  maxResults: '',
  nextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {maxResults: '', nextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"maxResults":"","nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"maxResults": @"",
                              @"nextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories"]
                                                       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=AwsProton20200720.ListRepositories" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'maxResults' => '',
    'nextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories', [
  'body' => '{
  "maxResults": "",
  "nextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'maxResults' => '',
  'nextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'maxResults' => '',
  'nextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories');
$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=AwsProton20200720.ListRepositories' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "maxResults": "",
  "nextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "maxResults": "",
  "nextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories"

payload = {
    "maxResults": "",
    "nextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories"

payload <- "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories";

    let payload = json!({
        "maxResults": "",
        "nextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "maxResults": "",
  "nextToken": ""
}'

echo '{
  "maxResults": "",
  "nextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "maxResults": "",\n  "nextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "maxResults": "",
  "nextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositories")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListRepositorySyncDefinitions

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositorySyncDefinitions

HEADERS

X-Amz-Target

BODY json

{
  "nextToken": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "syncType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositorySyncDefinitions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"nextToken\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositorySyncDefinitions" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:nextToken ""
                                                                                                                        :repositoryName ""
                                                                                                                        :repositoryProvider ""
                                                                                                                        :syncType ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositorySyncDefinitions"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"nextToken\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\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=AwsProton20200720.ListRepositorySyncDefinitions"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"nextToken\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\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=AwsProton20200720.ListRepositorySyncDefinitions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"nextToken\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositorySyncDefinitions"

	payload := strings.NewReader("{\n  \"nextToken\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\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: 91

{
  "nextToken": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "syncType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositorySyncDefinitions")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"nextToken\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositorySyncDefinitions"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"nextToken\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"nextToken\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositorySyncDefinitions")
  .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=AwsProton20200720.ListRepositorySyncDefinitions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"nextToken\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  nextToken: '',
  repositoryName: '',
  repositoryProvider: '',
  syncType: ''
});

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=AwsProton20200720.ListRepositorySyncDefinitions');
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=AwsProton20200720.ListRepositorySyncDefinitions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {nextToken: '', repositoryName: '', repositoryProvider: '', syncType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositorySyncDefinitions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"nextToken":"","repositoryName":"","repositoryProvider":"","syncType":""}'
};

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=AwsProton20200720.ListRepositorySyncDefinitions',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "nextToken": "",\n  "repositoryName": "",\n  "repositoryProvider": "",\n  "syncType": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"nextToken\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositorySyncDefinitions")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({nextToken: '', repositoryName: '', repositoryProvider: '', syncType: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositorySyncDefinitions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {nextToken: '', repositoryName: '', repositoryProvider: '', syncType: ''},
  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=AwsProton20200720.ListRepositorySyncDefinitions');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  nextToken: '',
  repositoryName: '',
  repositoryProvider: '',
  syncType: ''
});

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=AwsProton20200720.ListRepositorySyncDefinitions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {nextToken: '', repositoryName: '', repositoryProvider: '', syncType: ''}
};

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=AwsProton20200720.ListRepositorySyncDefinitions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"nextToken":"","repositoryName":"","repositoryProvider":"","syncType":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"nextToken": @"",
                              @"repositoryName": @"",
                              @"repositoryProvider": @"",
                              @"syncType": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositorySyncDefinitions"]
                                                       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=AwsProton20200720.ListRepositorySyncDefinitions" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"nextToken\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositorySyncDefinitions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'nextToken' => '',
    'repositoryName' => '',
    'repositoryProvider' => '',
    'syncType' => ''
  ]),
  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=AwsProton20200720.ListRepositorySyncDefinitions', [
  'body' => '{
  "nextToken": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "syncType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositorySyncDefinitions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'nextToken' => '',
  'repositoryName' => '',
  'repositoryProvider' => '',
  'syncType' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'nextToken' => '',
  'repositoryName' => '',
  'repositoryProvider' => '',
  'syncType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositorySyncDefinitions');
$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=AwsProton20200720.ListRepositorySyncDefinitions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "nextToken": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "syncType": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositorySyncDefinitions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "nextToken": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "syncType": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"nextToken\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\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=AwsProton20200720.ListRepositorySyncDefinitions"

payload = {
    "nextToken": "",
    "repositoryName": "",
    "repositoryProvider": "",
    "syncType": ""
}
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=AwsProton20200720.ListRepositorySyncDefinitions"

payload <- "{\n  \"nextToken\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\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=AwsProton20200720.ListRepositorySyncDefinitions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"nextToken\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"nextToken\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"syncType\": \"\"\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=AwsProton20200720.ListRepositorySyncDefinitions";

    let payload = json!({
        "nextToken": "",
        "repositoryName": "",
        "repositoryProvider": "",
        "syncType": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositorySyncDefinitions' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "nextToken": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "syncType": ""
}'

echo '{
  "nextToken": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "syncType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositorySyncDefinitions' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "nextToken": "",\n  "repositoryName": "",\n  "repositoryProvider": "",\n  "syncType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositorySyncDefinitions'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "nextToken": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "syncType": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListRepositorySyncDefinitions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListServiceInstanceOutputs

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceOutputs

HEADERS

X-Amz-Target

BODY json

{
  "nextToken": "",
  "serviceInstanceName": "",
  "serviceName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceOutputs");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceOutputs" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:nextToken ""
                                                                                                                     :serviceInstanceName ""
                                                                                                                     :serviceName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceOutputs"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.ListServiceInstanceOutputs"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.ListServiceInstanceOutputs");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceOutputs"

	payload := strings.NewReader("{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 71

{
  "nextToken": "",
  "serviceInstanceName": "",
  "serviceName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceOutputs")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceOutputs"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceOutputs")
  .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=AwsProton20200720.ListServiceInstanceOutputs")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  nextToken: '',
  serviceInstanceName: '',
  serviceName: ''
});

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=AwsProton20200720.ListServiceInstanceOutputs');
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=AwsProton20200720.ListServiceInstanceOutputs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {nextToken: '', serviceInstanceName: '', serviceName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceOutputs';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"nextToken":"","serviceInstanceName":"","serviceName":""}'
};

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=AwsProton20200720.ListServiceInstanceOutputs',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "nextToken": "",\n  "serviceInstanceName": "",\n  "serviceName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceOutputs")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({nextToken: '', serviceInstanceName: '', serviceName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceOutputs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {nextToken: '', serviceInstanceName: '', serviceName: ''},
  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=AwsProton20200720.ListServiceInstanceOutputs');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  nextToken: '',
  serviceInstanceName: '',
  serviceName: ''
});

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=AwsProton20200720.ListServiceInstanceOutputs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {nextToken: '', serviceInstanceName: '', serviceName: ''}
};

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=AwsProton20200720.ListServiceInstanceOutputs';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"nextToken":"","serviceInstanceName":"","serviceName":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"nextToken": @"",
                              @"serviceInstanceName": @"",
                              @"serviceName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceOutputs"]
                                                       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=AwsProton20200720.ListServiceInstanceOutputs" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceOutputs",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'nextToken' => '',
    'serviceInstanceName' => '',
    'serviceName' => ''
  ]),
  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=AwsProton20200720.ListServiceInstanceOutputs', [
  'body' => '{
  "nextToken": "",
  "serviceInstanceName": "",
  "serviceName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceOutputs');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'nextToken' => '',
  'serviceInstanceName' => '',
  'serviceName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'nextToken' => '',
  'serviceInstanceName' => '',
  'serviceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceOutputs');
$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=AwsProton20200720.ListServiceInstanceOutputs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "nextToken": "",
  "serviceInstanceName": "",
  "serviceName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceOutputs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "nextToken": "",
  "serviceInstanceName": "",
  "serviceName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.ListServiceInstanceOutputs"

payload = {
    "nextToken": "",
    "serviceInstanceName": "",
    "serviceName": ""
}
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=AwsProton20200720.ListServiceInstanceOutputs"

payload <- "{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.ListServiceInstanceOutputs")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.ListServiceInstanceOutputs";

    let payload = json!({
        "nextToken": "",
        "serviceInstanceName": "",
        "serviceName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceOutputs' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "nextToken": "",
  "serviceInstanceName": "",
  "serviceName": ""
}'

echo '{
  "nextToken": "",
  "serviceInstanceName": "",
  "serviceName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceOutputs' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "nextToken": "",\n  "serviceInstanceName": "",\n  "serviceName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceOutputs'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "nextToken": "",
  "serviceInstanceName": "",
  "serviceName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceOutputs")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListServiceInstanceProvisionedResources

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceProvisionedResources

HEADERS

X-Amz-Target

BODY json

{
  "nextToken": "",
  "serviceInstanceName": "",
  "serviceName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceProvisionedResources");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceProvisionedResources" {:headers {:x-amz-target ""}
                                                                                                                    :content-type :json
                                                                                                                    :form-params {:nextToken ""
                                                                                                                                  :serviceInstanceName ""
                                                                                                                                  :serviceName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceProvisionedResources"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.ListServiceInstanceProvisionedResources"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.ListServiceInstanceProvisionedResources");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceProvisionedResources"

	payload := strings.NewReader("{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 71

{
  "nextToken": "",
  "serviceInstanceName": "",
  "serviceName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceProvisionedResources")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceProvisionedResources"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceProvisionedResources")
  .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=AwsProton20200720.ListServiceInstanceProvisionedResources")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  nextToken: '',
  serviceInstanceName: '',
  serviceName: ''
});

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=AwsProton20200720.ListServiceInstanceProvisionedResources');
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=AwsProton20200720.ListServiceInstanceProvisionedResources',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {nextToken: '', serviceInstanceName: '', serviceName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceProvisionedResources';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"nextToken":"","serviceInstanceName":"","serviceName":""}'
};

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=AwsProton20200720.ListServiceInstanceProvisionedResources',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "nextToken": "",\n  "serviceInstanceName": "",\n  "serviceName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceProvisionedResources")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({nextToken: '', serviceInstanceName: '', serviceName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceProvisionedResources',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {nextToken: '', serviceInstanceName: '', serviceName: ''},
  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=AwsProton20200720.ListServiceInstanceProvisionedResources');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  nextToken: '',
  serviceInstanceName: '',
  serviceName: ''
});

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=AwsProton20200720.ListServiceInstanceProvisionedResources',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {nextToken: '', serviceInstanceName: '', serviceName: ''}
};

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=AwsProton20200720.ListServiceInstanceProvisionedResources';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"nextToken":"","serviceInstanceName":"","serviceName":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"nextToken": @"",
                              @"serviceInstanceName": @"",
                              @"serviceName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceProvisionedResources"]
                                                       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=AwsProton20200720.ListServiceInstanceProvisionedResources" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceProvisionedResources",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'nextToken' => '',
    'serviceInstanceName' => '',
    'serviceName' => ''
  ]),
  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=AwsProton20200720.ListServiceInstanceProvisionedResources', [
  'body' => '{
  "nextToken": "",
  "serviceInstanceName": "",
  "serviceName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceProvisionedResources');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'nextToken' => '',
  'serviceInstanceName' => '',
  'serviceName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'nextToken' => '',
  'serviceInstanceName' => '',
  'serviceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceProvisionedResources');
$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=AwsProton20200720.ListServiceInstanceProvisionedResources' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "nextToken": "",
  "serviceInstanceName": "",
  "serviceName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceProvisionedResources' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "nextToken": "",
  "serviceInstanceName": "",
  "serviceName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.ListServiceInstanceProvisionedResources"

payload = {
    "nextToken": "",
    "serviceInstanceName": "",
    "serviceName": ""
}
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=AwsProton20200720.ListServiceInstanceProvisionedResources"

payload <- "{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.ListServiceInstanceProvisionedResources")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"nextToken\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.ListServiceInstanceProvisionedResources";

    let payload = json!({
        "nextToken": "",
        "serviceInstanceName": "",
        "serviceName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceProvisionedResources' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "nextToken": "",
  "serviceInstanceName": "",
  "serviceName": ""
}'

echo '{
  "nextToken": "",
  "serviceInstanceName": "",
  "serviceName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceProvisionedResources' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "nextToken": "",\n  "serviceInstanceName": "",\n  "serviceName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceProvisionedResources'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "nextToken": "",
  "serviceInstanceName": "",
  "serviceName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstanceProvisionedResources")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListServiceInstances

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstances

HEADERS

X-Amz-Target

BODY json

{
  "filters": "",
  "maxResults": "",
  "nextToken": "",
  "serviceName": "",
  "sortBy": "",
  "sortOrder": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstances");

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  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceName\": \"\",\n  \"sortBy\": \"\",\n  \"sortOrder\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstances" {:headers {:x-amz-target ""}
                                                                                                 :content-type :json
                                                                                                 :form-params {:filters ""
                                                                                                               :maxResults ""
                                                                                                               :nextToken ""
                                                                                                               :serviceName ""
                                                                                                               :sortBy ""
                                                                                                               :sortOrder ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstances"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"filters\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceName\": \"\",\n  \"sortBy\": \"\",\n  \"sortOrder\": \"\"\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=AwsProton20200720.ListServiceInstances"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"filters\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceName\": \"\",\n  \"sortBy\": \"\",\n  \"sortOrder\": \"\"\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=AwsProton20200720.ListServiceInstances");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"filters\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceName\": \"\",\n  \"sortBy\": \"\",\n  \"sortOrder\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstances"

	payload := strings.NewReader("{\n  \"filters\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceName\": \"\",\n  \"sortBy\": \"\",\n  \"sortOrder\": \"\"\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: 114

{
  "filters": "",
  "maxResults": "",
  "nextToken": "",
  "serviceName": "",
  "sortBy": "",
  "sortOrder": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstances")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"filters\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceName\": \"\",\n  \"sortBy\": \"\",\n  \"sortOrder\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstances"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"filters\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceName\": \"\",\n  \"sortBy\": \"\",\n  \"sortOrder\": \"\"\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  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceName\": \"\",\n  \"sortBy\": \"\",\n  \"sortOrder\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstances")
  .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=AwsProton20200720.ListServiceInstances")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"filters\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceName\": \"\",\n  \"sortBy\": \"\",\n  \"sortOrder\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  filters: '',
  maxResults: '',
  nextToken: '',
  serviceName: '',
  sortBy: '',
  sortOrder: ''
});

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=AwsProton20200720.ListServiceInstances');
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=AwsProton20200720.ListServiceInstances',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    filters: '',
    maxResults: '',
    nextToken: '',
    serviceName: '',
    sortBy: '',
    sortOrder: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstances';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"filters":"","maxResults":"","nextToken":"","serviceName":"","sortBy":"","sortOrder":""}'
};

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=AwsProton20200720.ListServiceInstances',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "filters": "",\n  "maxResults": "",\n  "nextToken": "",\n  "serviceName": "",\n  "sortBy": "",\n  "sortOrder": ""\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  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceName\": \"\",\n  \"sortBy\": \"\",\n  \"sortOrder\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstances")
  .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: '',
  maxResults: '',
  nextToken: '',
  serviceName: '',
  sortBy: '',
  sortOrder: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstances',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    filters: '',
    maxResults: '',
    nextToken: '',
    serviceName: '',
    sortBy: '',
    sortOrder: ''
  },
  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=AwsProton20200720.ListServiceInstances');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  filters: '',
  maxResults: '',
  nextToken: '',
  serviceName: '',
  sortBy: '',
  sortOrder: ''
});

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=AwsProton20200720.ListServiceInstances',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    filters: '',
    maxResults: '',
    nextToken: '',
    serviceName: '',
    sortBy: '',
    sortOrder: ''
  }
};

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=AwsProton20200720.ListServiceInstances';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"filters":"","maxResults":"","nextToken":"","serviceName":"","sortBy":"","sortOrder":""}'
};

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": @"",
                              @"maxResults": @"",
                              @"nextToken": @"",
                              @"serviceName": @"",
                              @"sortBy": @"",
                              @"sortOrder": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstances"]
                                                       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=AwsProton20200720.ListServiceInstances" 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  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceName\": \"\",\n  \"sortBy\": \"\",\n  \"sortOrder\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstances",
  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' => '',
    'maxResults' => '',
    'nextToken' => '',
    'serviceName' => '',
    'sortBy' => '',
    'sortOrder' => ''
  ]),
  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=AwsProton20200720.ListServiceInstances', [
  'body' => '{
  "filters": "",
  "maxResults": "",
  "nextToken": "",
  "serviceName": "",
  "sortBy": "",
  "sortOrder": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstances');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'filters' => '',
  'maxResults' => '',
  'nextToken' => '',
  'serviceName' => '',
  'sortBy' => '',
  'sortOrder' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'filters' => '',
  'maxResults' => '',
  'nextToken' => '',
  'serviceName' => '',
  'sortBy' => '',
  'sortOrder' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstances');
$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=AwsProton20200720.ListServiceInstances' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "filters": "",
  "maxResults": "",
  "nextToken": "",
  "serviceName": "",
  "sortBy": "",
  "sortOrder": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstances' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "filters": "",
  "maxResults": "",
  "nextToken": "",
  "serviceName": "",
  "sortBy": "",
  "sortOrder": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"filters\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceName\": \"\",\n  \"sortBy\": \"\",\n  \"sortOrder\": \"\"\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=AwsProton20200720.ListServiceInstances"

payload = {
    "filters": "",
    "maxResults": "",
    "nextToken": "",
    "serviceName": "",
    "sortBy": "",
    "sortOrder": ""
}
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=AwsProton20200720.ListServiceInstances"

payload <- "{\n  \"filters\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceName\": \"\",\n  \"sortBy\": \"\",\n  \"sortOrder\": \"\"\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=AwsProton20200720.ListServiceInstances")

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  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceName\": \"\",\n  \"sortBy\": \"\",\n  \"sortOrder\": \"\"\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  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"serviceName\": \"\",\n  \"sortBy\": \"\",\n  \"sortOrder\": \"\"\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=AwsProton20200720.ListServiceInstances";

    let payload = json!({
        "filters": "",
        "maxResults": "",
        "nextToken": "",
        "serviceName": "",
        "sortBy": "",
        "sortOrder": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstances' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "filters": "",
  "maxResults": "",
  "nextToken": "",
  "serviceName": "",
  "sortBy": "",
  "sortOrder": ""
}'

echo '{
  "filters": "",
  "maxResults": "",
  "nextToken": "",
  "serviceName": "",
  "sortBy": "",
  "sortOrder": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstances' \
  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  "maxResults": "",\n  "nextToken": "",\n  "serviceName": "",\n  "sortBy": "",\n  "sortOrder": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstances'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "filters": "",
  "maxResults": "",
  "nextToken": "",
  "serviceName": "",
  "sortBy": "",
  "sortOrder": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceInstances")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListServicePipelineOutputs

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineOutputs

HEADERS

X-Amz-Target

BODY json

{
  "nextToken": "",
  "serviceName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineOutputs");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineOutputs" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:nextToken ""
                                                                                                                     :serviceName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineOutputs"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.ListServicePipelineOutputs"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.ListServicePipelineOutputs");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineOutputs"

	payload := strings.NewReader("{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 42

{
  "nextToken": "",
  "serviceName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineOutputs")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineOutputs"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineOutputs")
  .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=AwsProton20200720.ListServicePipelineOutputs")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  nextToken: '',
  serviceName: ''
});

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=AwsProton20200720.ListServicePipelineOutputs');
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=AwsProton20200720.ListServicePipelineOutputs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {nextToken: '', serviceName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineOutputs';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"nextToken":"","serviceName":""}'
};

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=AwsProton20200720.ListServicePipelineOutputs',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "nextToken": "",\n  "serviceName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineOutputs")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({nextToken: '', serviceName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineOutputs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {nextToken: '', serviceName: ''},
  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=AwsProton20200720.ListServicePipelineOutputs');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  nextToken: '',
  serviceName: ''
});

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=AwsProton20200720.ListServicePipelineOutputs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {nextToken: '', serviceName: ''}
};

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=AwsProton20200720.ListServicePipelineOutputs';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"nextToken":"","serviceName":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"nextToken": @"",
                              @"serviceName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineOutputs"]
                                                       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=AwsProton20200720.ListServicePipelineOutputs" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineOutputs",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'nextToken' => '',
    'serviceName' => ''
  ]),
  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=AwsProton20200720.ListServicePipelineOutputs', [
  'body' => '{
  "nextToken": "",
  "serviceName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineOutputs');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'nextToken' => '',
  'serviceName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'nextToken' => '',
  'serviceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineOutputs');
$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=AwsProton20200720.ListServicePipelineOutputs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "nextToken": "",
  "serviceName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineOutputs' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "nextToken": "",
  "serviceName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.ListServicePipelineOutputs"

payload = {
    "nextToken": "",
    "serviceName": ""
}
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=AwsProton20200720.ListServicePipelineOutputs"

payload <- "{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.ListServicePipelineOutputs")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.ListServicePipelineOutputs";

    let payload = json!({
        "nextToken": "",
        "serviceName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineOutputs' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "nextToken": "",
  "serviceName": ""
}'

echo '{
  "nextToken": "",
  "serviceName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineOutputs' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "nextToken": "",\n  "serviceName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineOutputs'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "nextToken": "",
  "serviceName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineOutputs")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListServicePipelineProvisionedResources

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineProvisionedResources

HEADERS

X-Amz-Target

BODY json

{
  "nextToken": "",
  "serviceName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineProvisionedResources");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineProvisionedResources" {:headers {:x-amz-target ""}
                                                                                                                    :content-type :json
                                                                                                                    :form-params {:nextToken ""
                                                                                                                                  :serviceName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineProvisionedResources"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.ListServicePipelineProvisionedResources"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.ListServicePipelineProvisionedResources");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineProvisionedResources"

	payload := strings.NewReader("{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 42

{
  "nextToken": "",
  "serviceName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineProvisionedResources")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineProvisionedResources"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineProvisionedResources")
  .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=AwsProton20200720.ListServicePipelineProvisionedResources")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  nextToken: '',
  serviceName: ''
});

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=AwsProton20200720.ListServicePipelineProvisionedResources');
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=AwsProton20200720.ListServicePipelineProvisionedResources',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {nextToken: '', serviceName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineProvisionedResources';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"nextToken":"","serviceName":""}'
};

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=AwsProton20200720.ListServicePipelineProvisionedResources',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "nextToken": "",\n  "serviceName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineProvisionedResources")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({nextToken: '', serviceName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineProvisionedResources',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {nextToken: '', serviceName: ''},
  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=AwsProton20200720.ListServicePipelineProvisionedResources');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  nextToken: '',
  serviceName: ''
});

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=AwsProton20200720.ListServicePipelineProvisionedResources',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {nextToken: '', serviceName: ''}
};

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=AwsProton20200720.ListServicePipelineProvisionedResources';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"nextToken":"","serviceName":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"nextToken": @"",
                              @"serviceName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineProvisionedResources"]
                                                       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=AwsProton20200720.ListServicePipelineProvisionedResources" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineProvisionedResources",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'nextToken' => '',
    'serviceName' => ''
  ]),
  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=AwsProton20200720.ListServicePipelineProvisionedResources', [
  'body' => '{
  "nextToken": "",
  "serviceName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineProvisionedResources');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'nextToken' => '',
  'serviceName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'nextToken' => '',
  'serviceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineProvisionedResources');
$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=AwsProton20200720.ListServicePipelineProvisionedResources' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "nextToken": "",
  "serviceName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineProvisionedResources' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "nextToken": "",
  "serviceName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.ListServicePipelineProvisionedResources"

payload = {
    "nextToken": "",
    "serviceName": ""
}
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=AwsProton20200720.ListServicePipelineProvisionedResources"

payload <- "{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.ListServicePipelineProvisionedResources")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"nextToken\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.ListServicePipelineProvisionedResources";

    let payload = json!({
        "nextToken": "",
        "serviceName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineProvisionedResources' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "nextToken": "",
  "serviceName": ""
}'

echo '{
  "nextToken": "",
  "serviceName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineProvisionedResources' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "nextToken": "",\n  "serviceName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineProvisionedResources'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "nextToken": "",
  "serviceName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServicePipelineProvisionedResources")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListServiceTemplateVersions

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplateVersions

HEADERS

X-Amz-Target

BODY json

{
  "majorVersion": "",
  "maxResults": "",
  "nextToken": "",
  "templateName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplateVersions");

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  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplateVersions" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:majorVersion ""
                                                                                                                      :maxResults ""
                                                                                                                      :nextToken ""
                                                                                                                      :templateName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplateVersions"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.ListServiceTemplateVersions"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.ListServiceTemplateVersions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplateVersions"

	payload := strings.NewReader("{\n  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\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: 85

{
  "majorVersion": "",
  "maxResults": "",
  "nextToken": "",
  "templateName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplateVersions")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplateVersions"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\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  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplateVersions")
  .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=AwsProton20200720.ListServiceTemplateVersions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  majorVersion: '',
  maxResults: '',
  nextToken: '',
  templateName: ''
});

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=AwsProton20200720.ListServiceTemplateVersions');
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=AwsProton20200720.ListServiceTemplateVersions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {majorVersion: '', maxResults: '', nextToken: '', templateName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplateVersions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"majorVersion":"","maxResults":"","nextToken":"","templateName":""}'
};

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=AwsProton20200720.ListServiceTemplateVersions',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "majorVersion": "",\n  "maxResults": "",\n  "nextToken": "",\n  "templateName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplateVersions")
  .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({majorVersion: '', maxResults: '', nextToken: '', templateName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplateVersions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {majorVersion: '', maxResults: '', nextToken: '', templateName: ''},
  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=AwsProton20200720.ListServiceTemplateVersions');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  majorVersion: '',
  maxResults: '',
  nextToken: '',
  templateName: ''
});

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=AwsProton20200720.ListServiceTemplateVersions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {majorVersion: '', maxResults: '', nextToken: '', templateName: ''}
};

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=AwsProton20200720.ListServiceTemplateVersions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"majorVersion":"","maxResults":"","nextToken":"","templateName":""}'
};

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 = @{ @"majorVersion": @"",
                              @"maxResults": @"",
                              @"nextToken": @"",
                              @"templateName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplateVersions"]
                                                       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=AwsProton20200720.ListServiceTemplateVersions" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplateVersions",
  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([
    'majorVersion' => '',
    'maxResults' => '',
    'nextToken' => '',
    'templateName' => ''
  ]),
  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=AwsProton20200720.ListServiceTemplateVersions', [
  'body' => '{
  "majorVersion": "",
  "maxResults": "",
  "nextToken": "",
  "templateName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplateVersions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'majorVersion' => '',
  'maxResults' => '',
  'nextToken' => '',
  'templateName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'majorVersion' => '',
  'maxResults' => '',
  'nextToken' => '',
  'templateName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplateVersions');
$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=AwsProton20200720.ListServiceTemplateVersions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "majorVersion": "",
  "maxResults": "",
  "nextToken": "",
  "templateName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplateVersions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "majorVersion": "",
  "maxResults": "",
  "nextToken": "",
  "templateName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.ListServiceTemplateVersions"

payload = {
    "majorVersion": "",
    "maxResults": "",
    "nextToken": "",
    "templateName": ""
}
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=AwsProton20200720.ListServiceTemplateVersions"

payload <- "{\n  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.ListServiceTemplateVersions")

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  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\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  \"majorVersion\": \"\",\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.ListServiceTemplateVersions";

    let payload = json!({
        "majorVersion": "",
        "maxResults": "",
        "nextToken": "",
        "templateName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplateVersions' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "majorVersion": "",
  "maxResults": "",
  "nextToken": "",
  "templateName": ""
}'

echo '{
  "majorVersion": "",
  "maxResults": "",
  "nextToken": "",
  "templateName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplateVersions' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "majorVersion": "",\n  "maxResults": "",\n  "nextToken": "",\n  "templateName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplateVersions'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "majorVersion": "",
  "maxResults": "",
  "nextToken": "",
  "templateName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplateVersions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListServiceTemplates

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates

HEADERS

X-Amz-Target

BODY json

{
  "maxResults": "",
  "nextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates" {:headers {:x-amz-target ""}
                                                                                                 :content-type :json
                                                                                                 :form-params {:maxResults ""
                                                                                                               :nextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates"

	payload := strings.NewReader("{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 41

{
  "maxResults": "",
  "nextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates")
  .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=AwsProton20200720.ListServiceTemplates")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  maxResults: '',
  nextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates');
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=AwsProton20200720.ListServiceTemplates',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {maxResults: '', nextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"maxResults":"","nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "maxResults": "",\n  "nextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({maxResults: '', nextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {maxResults: '', nextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  maxResults: '',
  nextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {maxResults: '', nextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"maxResults":"","nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"maxResults": @"",
                              @"nextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates"]
                                                       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=AwsProton20200720.ListServiceTemplates" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'maxResults' => '',
    'nextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates', [
  'body' => '{
  "maxResults": "",
  "nextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'maxResults' => '',
  'nextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'maxResults' => '',
  'nextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates');
$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=AwsProton20200720.ListServiceTemplates' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "maxResults": "",
  "nextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "maxResults": "",
  "nextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates"

payload = {
    "maxResults": "",
    "nextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates"

payload <- "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates";

    let payload = json!({
        "maxResults": "",
        "nextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "maxResults": "",
  "nextToken": ""
}'

echo '{
  "maxResults": "",
  "nextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "maxResults": "",\n  "nextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "maxResults": "",
  "nextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServiceTemplates")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListServices

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices

HEADERS

X-Amz-Target

BODY json

{
  "maxResults": "",
  "nextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices" {:headers {:x-amz-target ""}
                                                                                         :content-type :json
                                                                                         :form-params {:maxResults ""
                                                                                                       :nextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices"

	payload := strings.NewReader("{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 41

{
  "maxResults": "",
  "nextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices")
  .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=AwsProton20200720.ListServices")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  maxResults: '',
  nextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices');
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=AwsProton20200720.ListServices',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {maxResults: '', nextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"maxResults":"","nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "maxResults": "",\n  "nextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({maxResults: '', nextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {maxResults: '', nextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  maxResults: '',
  nextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {maxResults: '', nextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"maxResults":"","nextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"maxResults": @"",
                              @"nextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices"]
                                                       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=AwsProton20200720.ListServices" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'maxResults' => '',
    'nextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices', [
  'body' => '{
  "maxResults": "",
  "nextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'maxResults' => '',
  'nextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'maxResults' => '',
  'nextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices');
$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=AwsProton20200720.ListServices' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "maxResults": "",
  "nextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "maxResults": "",
  "nextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices"

payload = {
    "maxResults": "",
    "nextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices"

payload <- "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices";

    let payload = json!({
        "maxResults": "",
        "nextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "maxResults": "",
  "nextToken": ""
}'

echo '{
  "maxResults": "",
  "nextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "maxResults": "",\n  "nextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "maxResults": "",
  "nextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListServices")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST ListTagsForResource

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListTagsForResource

HEADERS

X-Amz-Target

BODY json

{
  "maxResults": "",
  "nextToken": "",
  "resourceArn": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListTagsForResource");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"resourceArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListTagsForResource" {:headers {:x-amz-target ""}
                                                                                                :content-type :json
                                                                                                :form-params {:maxResults ""
                                                                                                              :nextToken ""
                                                                                                              :resourceArn ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListTagsForResource"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\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=AwsProton20200720.ListTagsForResource"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\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=AwsProton20200720.ListTagsForResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"resourceArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListTagsForResource"

	payload := strings.NewReader("{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\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: 62

{
  "maxResults": "",
  "nextToken": "",
  "resourceArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListTagsForResource")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"resourceArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListTagsForResource"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\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  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"resourceArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListTagsForResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListTagsForResource")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"resourceArn\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  maxResults: '',
  nextToken: '',
  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=AwsProton20200720.ListTagsForResource');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListTagsForResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {maxResults: '', nextToken: '', resourceArn: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListTagsForResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"maxResults":"","nextToken":"","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=AwsProton20200720.ListTagsForResource',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "maxResults": "",\n  "nextToken": "",\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  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"resourceArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListTagsForResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({maxResults: '', nextToken: '', resourceArn: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListTagsForResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {maxResults: '', nextToken: '', 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=AwsProton20200720.ListTagsForResource');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  maxResults: '',
  nextToken: '',
  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=AwsProton20200720.ListTagsForResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {maxResults: '', nextToken: '', 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=AwsProton20200720.ListTagsForResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"maxResults":"","nextToken":"","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 = @{ @"maxResults": @"",
                              @"nextToken": @"",
                              @"resourceArn": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListTagsForResource"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListTagsForResource" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\n  \"resourceArn\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListTagsForResource",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'maxResults' => '',
    'nextToken' => '',
    '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=AwsProton20200720.ListTagsForResource', [
  'body' => '{
  "maxResults": "",
  "nextToken": "",
  "resourceArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListTagsForResource');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'maxResults' => '',
  'nextToken' => '',
  'resourceArn' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'maxResults' => '',
  'nextToken' => '',
  'resourceArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListTagsForResource');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListTagsForResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "maxResults": "",
  "nextToken": "",
  "resourceArn": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListTagsForResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "maxResults": "",
  "nextToken": "",
  "resourceArn": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\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=AwsProton20200720.ListTagsForResource"

payload = {
    "maxResults": "",
    "nextToken": "",
    "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=AwsProton20200720.ListTagsForResource"

payload <- "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\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=AwsProton20200720.ListTagsForResource")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"maxResults\": \"\",\n  \"nextToken\": \"\",\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  \"maxResults\": \"\",\n  \"nextToken\": \"\",\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=AwsProton20200720.ListTagsForResource";

    let payload = json!({
        "maxResults": "",
        "nextToken": "",
        "resourceArn": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListTagsForResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "maxResults": "",
  "nextToken": "",
  "resourceArn": ""
}'

echo '{
  "maxResults": "",
  "nextToken": "",
  "resourceArn": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListTagsForResource' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "maxResults": "",\n  "nextToken": "",\n  "resourceArn": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListTagsForResource'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "maxResults": "",
  "nextToken": "",
  "resourceArn": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.ListTagsForResource")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST NotifyResourceDeploymentStatusChange

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.NotifyResourceDeploymentStatusChange

HEADERS

X-Amz-Target

BODY json

{
  "deploymentId": "",
  "outputs": "",
  "resourceArn": "",
  "status": "",
  "statusMessage": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.NotifyResourceDeploymentStatusChange");

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  \"deploymentId\": \"\",\n  \"outputs\": \"\",\n  \"resourceArn\": \"\",\n  \"status\": \"\",\n  \"statusMessage\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.NotifyResourceDeploymentStatusChange" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:deploymentId ""
                                                                                                                               :outputs ""
                                                                                                                               :resourceArn ""
                                                                                                                               :status ""
                                                                                                                               :statusMessage ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.NotifyResourceDeploymentStatusChange"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"deploymentId\": \"\",\n  \"outputs\": \"\",\n  \"resourceArn\": \"\",\n  \"status\": \"\",\n  \"statusMessage\": \"\"\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=AwsProton20200720.NotifyResourceDeploymentStatusChange"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"deploymentId\": \"\",\n  \"outputs\": \"\",\n  \"resourceArn\": \"\",\n  \"status\": \"\",\n  \"statusMessage\": \"\"\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=AwsProton20200720.NotifyResourceDeploymentStatusChange");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"deploymentId\": \"\",\n  \"outputs\": \"\",\n  \"resourceArn\": \"\",\n  \"status\": \"\",\n  \"statusMessage\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.NotifyResourceDeploymentStatusChange"

	payload := strings.NewReader("{\n  \"deploymentId\": \"\",\n  \"outputs\": \"\",\n  \"resourceArn\": \"\",\n  \"status\": \"\",\n  \"statusMessage\": \"\"\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: 101

{
  "deploymentId": "",
  "outputs": "",
  "resourceArn": "",
  "status": "",
  "statusMessage": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.NotifyResourceDeploymentStatusChange")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"deploymentId\": \"\",\n  \"outputs\": \"\",\n  \"resourceArn\": \"\",\n  \"status\": \"\",\n  \"statusMessage\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.NotifyResourceDeploymentStatusChange"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"deploymentId\": \"\",\n  \"outputs\": \"\",\n  \"resourceArn\": \"\",\n  \"status\": \"\",\n  \"statusMessage\": \"\"\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  \"deploymentId\": \"\",\n  \"outputs\": \"\",\n  \"resourceArn\": \"\",\n  \"status\": \"\",\n  \"statusMessage\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.NotifyResourceDeploymentStatusChange")
  .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=AwsProton20200720.NotifyResourceDeploymentStatusChange")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"deploymentId\": \"\",\n  \"outputs\": \"\",\n  \"resourceArn\": \"\",\n  \"status\": \"\",\n  \"statusMessage\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  deploymentId: '',
  outputs: '',
  resourceArn: '',
  status: '',
  statusMessage: ''
});

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=AwsProton20200720.NotifyResourceDeploymentStatusChange');
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=AwsProton20200720.NotifyResourceDeploymentStatusChange',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {deploymentId: '', outputs: '', resourceArn: '', status: '', statusMessage: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.NotifyResourceDeploymentStatusChange';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"deploymentId":"","outputs":"","resourceArn":"","status":"","statusMessage":""}'
};

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=AwsProton20200720.NotifyResourceDeploymentStatusChange',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "deploymentId": "",\n  "outputs": "",\n  "resourceArn": "",\n  "status": "",\n  "statusMessage": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"deploymentId\": \"\",\n  \"outputs\": \"\",\n  \"resourceArn\": \"\",\n  \"status\": \"\",\n  \"statusMessage\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.NotifyResourceDeploymentStatusChange")
  .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({deploymentId: '', outputs: '', resourceArn: '', status: '', statusMessage: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.NotifyResourceDeploymentStatusChange',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {deploymentId: '', outputs: '', resourceArn: '', status: '', statusMessage: ''},
  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=AwsProton20200720.NotifyResourceDeploymentStatusChange');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  deploymentId: '',
  outputs: '',
  resourceArn: '',
  status: '',
  statusMessage: ''
});

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=AwsProton20200720.NotifyResourceDeploymentStatusChange',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {deploymentId: '', outputs: '', resourceArn: '', status: '', statusMessage: ''}
};

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=AwsProton20200720.NotifyResourceDeploymentStatusChange';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"deploymentId":"","outputs":"","resourceArn":"","status":"","statusMessage":""}'
};

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 = @{ @"deploymentId": @"",
                              @"outputs": @"",
                              @"resourceArn": @"",
                              @"status": @"",
                              @"statusMessage": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.NotifyResourceDeploymentStatusChange"]
                                                       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=AwsProton20200720.NotifyResourceDeploymentStatusChange" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"deploymentId\": \"\",\n  \"outputs\": \"\",\n  \"resourceArn\": \"\",\n  \"status\": \"\",\n  \"statusMessage\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.NotifyResourceDeploymentStatusChange",
  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([
    'deploymentId' => '',
    'outputs' => '',
    'resourceArn' => '',
    'status' => '',
    'statusMessage' => ''
  ]),
  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=AwsProton20200720.NotifyResourceDeploymentStatusChange', [
  'body' => '{
  "deploymentId": "",
  "outputs": "",
  "resourceArn": "",
  "status": "",
  "statusMessage": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.NotifyResourceDeploymentStatusChange');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'deploymentId' => '',
  'outputs' => '',
  'resourceArn' => '',
  'status' => '',
  'statusMessage' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'deploymentId' => '',
  'outputs' => '',
  'resourceArn' => '',
  'status' => '',
  'statusMessage' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.NotifyResourceDeploymentStatusChange');
$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=AwsProton20200720.NotifyResourceDeploymentStatusChange' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "deploymentId": "",
  "outputs": "",
  "resourceArn": "",
  "status": "",
  "statusMessage": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.NotifyResourceDeploymentStatusChange' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "deploymentId": "",
  "outputs": "",
  "resourceArn": "",
  "status": "",
  "statusMessage": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"deploymentId\": \"\",\n  \"outputs\": \"\",\n  \"resourceArn\": \"\",\n  \"status\": \"\",\n  \"statusMessage\": \"\"\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=AwsProton20200720.NotifyResourceDeploymentStatusChange"

payload = {
    "deploymentId": "",
    "outputs": "",
    "resourceArn": "",
    "status": "",
    "statusMessage": ""
}
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=AwsProton20200720.NotifyResourceDeploymentStatusChange"

payload <- "{\n  \"deploymentId\": \"\",\n  \"outputs\": \"\",\n  \"resourceArn\": \"\",\n  \"status\": \"\",\n  \"statusMessage\": \"\"\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=AwsProton20200720.NotifyResourceDeploymentStatusChange")

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  \"deploymentId\": \"\",\n  \"outputs\": \"\",\n  \"resourceArn\": \"\",\n  \"status\": \"\",\n  \"statusMessage\": \"\"\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  \"deploymentId\": \"\",\n  \"outputs\": \"\",\n  \"resourceArn\": \"\",\n  \"status\": \"\",\n  \"statusMessage\": \"\"\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=AwsProton20200720.NotifyResourceDeploymentStatusChange";

    let payload = json!({
        "deploymentId": "",
        "outputs": "",
        "resourceArn": "",
        "status": "",
        "statusMessage": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.NotifyResourceDeploymentStatusChange' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "deploymentId": "",
  "outputs": "",
  "resourceArn": "",
  "status": "",
  "statusMessage": ""
}'

echo '{
  "deploymentId": "",
  "outputs": "",
  "resourceArn": "",
  "status": "",
  "statusMessage": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.NotifyResourceDeploymentStatusChange' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "deploymentId": "",\n  "outputs": "",\n  "resourceArn": "",\n  "status": "",\n  "statusMessage": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.NotifyResourceDeploymentStatusChange'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "deploymentId": "",
  "outputs": "",
  "resourceArn": "",
  "status": "",
  "statusMessage": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.NotifyResourceDeploymentStatusChange")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST RejectEnvironmentAccountConnection

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.RejectEnvironmentAccountConnection

HEADERS

X-Amz-Target

BODY json

{
  "id": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.RejectEnvironmentAccountConnection");

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  \"id\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.RejectEnvironmentAccountConnection" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:id ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.RejectEnvironmentAccountConnection"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": \"\"\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=AwsProton20200720.RejectEnvironmentAccountConnection"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"id\": \"\"\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=AwsProton20200720.RejectEnvironmentAccountConnection");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.RejectEnvironmentAccountConnection"

	payload := strings.NewReader("{\n  \"id\": \"\"\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: 14

{
  "id": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.RejectEnvironmentAccountConnection")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"id\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.RejectEnvironmentAccountConnection"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"id\": \"\"\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  \"id\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.RejectEnvironmentAccountConnection")
  .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=AwsProton20200720.RejectEnvironmentAccountConnection")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"id\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  id: ''
});

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=AwsProton20200720.RejectEnvironmentAccountConnection');
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=AwsProton20200720.RejectEnvironmentAccountConnection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {id: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.RejectEnvironmentAccountConnection';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"id":""}'
};

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=AwsProton20200720.RejectEnvironmentAccountConnection',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"id\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.RejectEnvironmentAccountConnection")
  .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({id: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.RejectEnvironmentAccountConnection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {id: ''},
  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=AwsProton20200720.RejectEnvironmentAccountConnection');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  id: ''
});

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=AwsProton20200720.RejectEnvironmentAccountConnection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {id: ''}
};

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=AwsProton20200720.RejectEnvironmentAccountConnection';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"id":""}'
};

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 = @{ @"id": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.RejectEnvironmentAccountConnection"]
                                                       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=AwsProton20200720.RejectEnvironmentAccountConnection" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"id\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.RejectEnvironmentAccountConnection",
  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([
    'id' => ''
  ]),
  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=AwsProton20200720.RejectEnvironmentAccountConnection', [
  'body' => '{
  "id": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.RejectEnvironmentAccountConnection');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'id' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'id' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.RejectEnvironmentAccountConnection');
$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=AwsProton20200720.RejectEnvironmentAccountConnection' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.RejectEnvironmentAccountConnection' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"id\": \"\"\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=AwsProton20200720.RejectEnvironmentAccountConnection"

payload = { "id": "" }
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=AwsProton20200720.RejectEnvironmentAccountConnection"

payload <- "{\n  \"id\": \"\"\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=AwsProton20200720.RejectEnvironmentAccountConnection")

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  \"id\": \"\"\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  \"id\": \"\"\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=AwsProton20200720.RejectEnvironmentAccountConnection";

    let payload = json!({"id": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.RejectEnvironmentAccountConnection' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "id": ""
}'

echo '{
  "id": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.RejectEnvironmentAccountConnection' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.RejectEnvironmentAccountConnection'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["id": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.RejectEnvironmentAccountConnection")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST TagResource

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource

HEADERS

X-Amz-Target

BODY json

{
  "resourceArn": "",
  "tags": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource" {:headers {:x-amz-target ""}
                                                                                        :content-type :json
                                                                                        :form-params {:resourceArn ""
                                                                                                      :tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource"

	payload := strings.NewReader("{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 37

{
  "resourceArn": "",
  "tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  resourceArn: '',
  tags: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {resourceArn: '', tags: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"resourceArn":"","tags":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resourceArn": "",\n  "tags": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({resourceArn: '', tags: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {resourceArn: '', tags: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  resourceArn: '',
  tags: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {resourceArn: '', tags: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"resourceArn":"","tags":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"resourceArn": @"",
                              @"tags": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'resourceArn' => '',
    'tags' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource', [
  'body' => '{
  "resourceArn": "",
  "tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resourceArn' => '',
  'tags' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'resourceArn' => '',
  'tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceArn": "",
  "tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceArn": "",
  "tags": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource"

payload = {
    "resourceArn": "",
    "tags": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource"

payload <- "{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"resourceArn\": \"\",\n  \"tags\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource";

    let payload = json!({
        "resourceArn": "",
        "tags": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "resourceArn": "",
  "tags": ""
}'

echo '{
  "resourceArn": "",
  "tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourceArn": "",\n  "tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "resourceArn": "",
  "tags": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.TagResource")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UntagResource

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource

HEADERS

X-Amz-Target

BODY json

{
  "resourceArn": "",
  "tagKeys": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource" {:headers {:x-amz-target ""}
                                                                                          :content-type :json
                                                                                          :form-params {:resourceArn ""
                                                                                                        :tagKeys ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource"

	payload := strings.NewReader("{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 40

{
  "resourceArn": "",
  "tagKeys": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  resourceArn: '',
  tagKeys: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {resourceArn: '', tagKeys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"resourceArn":"","tagKeys":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resourceArn": "",\n  "tagKeys": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({resourceArn: '', tagKeys: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {resourceArn: '', tagKeys: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  resourceArn: '',
  tagKeys: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {resourceArn: '', tagKeys: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"resourceArn":"","tagKeys":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"resourceArn": @"",
                              @"tagKeys": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'resourceArn' => '',
    'tagKeys' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource', [
  'body' => '{
  "resourceArn": "",
  "tagKeys": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resourceArn' => '',
  'tagKeys' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'resourceArn' => '',
  'tagKeys' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceArn": "",
  "tagKeys": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceArn": "",
  "tagKeys": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource"

payload = {
    "resourceArn": "",
    "tagKeys": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource"

payload <- "{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"resourceArn\": \"\",\n  \"tagKeys\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource";

    let payload = json!({
        "resourceArn": "",
        "tagKeys": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "resourceArn": "",
  "tagKeys": ""
}'

echo '{
  "resourceArn": "",
  "tagKeys": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourceArn": "",\n  "tagKeys": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "resourceArn": "",
  "tagKeys": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UntagResource")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateAccountSettings

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateAccountSettings

HEADERS

X-Amz-Target

BODY json

{
  "deletePipelineProvisioningRepository": "",
  "pipelineCodebuildRoleArn": "",
  "pipelineProvisioningRepository": "",
  "pipelineServiceRoleArn": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateAccountSettings");

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  \"deletePipelineProvisioningRepository\": \"\",\n  \"pipelineCodebuildRoleArn\": \"\",\n  \"pipelineProvisioningRepository\": \"\",\n  \"pipelineServiceRoleArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateAccountSettings" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:deletePipelineProvisioningRepository ""
                                                                                                                :pipelineCodebuildRoleArn ""
                                                                                                                :pipelineProvisioningRepository ""
                                                                                                                :pipelineServiceRoleArn ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateAccountSettings"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"deletePipelineProvisioningRepository\": \"\",\n  \"pipelineCodebuildRoleArn\": \"\",\n  \"pipelineProvisioningRepository\": \"\",\n  \"pipelineServiceRoleArn\": \"\"\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=AwsProton20200720.UpdateAccountSettings"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"deletePipelineProvisioningRepository\": \"\",\n  \"pipelineCodebuildRoleArn\": \"\",\n  \"pipelineProvisioningRepository\": \"\",\n  \"pipelineServiceRoleArn\": \"\"\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=AwsProton20200720.UpdateAccountSettings");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"deletePipelineProvisioningRepository\": \"\",\n  \"pipelineCodebuildRoleArn\": \"\",\n  \"pipelineProvisioningRepository\": \"\",\n  \"pipelineServiceRoleArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateAccountSettings"

	payload := strings.NewReader("{\n  \"deletePipelineProvisioningRepository\": \"\",\n  \"pipelineCodebuildRoleArn\": \"\",\n  \"pipelineProvisioningRepository\": \"\",\n  \"pipelineServiceRoleArn\": \"\"\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: 154

{
  "deletePipelineProvisioningRepository": "",
  "pipelineCodebuildRoleArn": "",
  "pipelineProvisioningRepository": "",
  "pipelineServiceRoleArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateAccountSettings")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"deletePipelineProvisioningRepository\": \"\",\n  \"pipelineCodebuildRoleArn\": \"\",\n  \"pipelineProvisioningRepository\": \"\",\n  \"pipelineServiceRoleArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateAccountSettings"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"deletePipelineProvisioningRepository\": \"\",\n  \"pipelineCodebuildRoleArn\": \"\",\n  \"pipelineProvisioningRepository\": \"\",\n  \"pipelineServiceRoleArn\": \"\"\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  \"deletePipelineProvisioningRepository\": \"\",\n  \"pipelineCodebuildRoleArn\": \"\",\n  \"pipelineProvisioningRepository\": \"\",\n  \"pipelineServiceRoleArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateAccountSettings")
  .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=AwsProton20200720.UpdateAccountSettings")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"deletePipelineProvisioningRepository\": \"\",\n  \"pipelineCodebuildRoleArn\": \"\",\n  \"pipelineProvisioningRepository\": \"\",\n  \"pipelineServiceRoleArn\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  deletePipelineProvisioningRepository: '',
  pipelineCodebuildRoleArn: '',
  pipelineProvisioningRepository: '',
  pipelineServiceRoleArn: ''
});

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=AwsProton20200720.UpdateAccountSettings');
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=AwsProton20200720.UpdateAccountSettings',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    deletePipelineProvisioningRepository: '',
    pipelineCodebuildRoleArn: '',
    pipelineProvisioningRepository: '',
    pipelineServiceRoleArn: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateAccountSettings';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"deletePipelineProvisioningRepository":"","pipelineCodebuildRoleArn":"","pipelineProvisioningRepository":"","pipelineServiceRoleArn":""}'
};

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=AwsProton20200720.UpdateAccountSettings',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "deletePipelineProvisioningRepository": "",\n  "pipelineCodebuildRoleArn": "",\n  "pipelineProvisioningRepository": "",\n  "pipelineServiceRoleArn": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"deletePipelineProvisioningRepository\": \"\",\n  \"pipelineCodebuildRoleArn\": \"\",\n  \"pipelineProvisioningRepository\": \"\",\n  \"pipelineServiceRoleArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateAccountSettings")
  .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({
  deletePipelineProvisioningRepository: '',
  pipelineCodebuildRoleArn: '',
  pipelineProvisioningRepository: '',
  pipelineServiceRoleArn: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateAccountSettings',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    deletePipelineProvisioningRepository: '',
    pipelineCodebuildRoleArn: '',
    pipelineProvisioningRepository: '',
    pipelineServiceRoleArn: ''
  },
  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=AwsProton20200720.UpdateAccountSettings');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  deletePipelineProvisioningRepository: '',
  pipelineCodebuildRoleArn: '',
  pipelineProvisioningRepository: '',
  pipelineServiceRoleArn: ''
});

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=AwsProton20200720.UpdateAccountSettings',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    deletePipelineProvisioningRepository: '',
    pipelineCodebuildRoleArn: '',
    pipelineProvisioningRepository: '',
    pipelineServiceRoleArn: ''
  }
};

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=AwsProton20200720.UpdateAccountSettings';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"deletePipelineProvisioningRepository":"","pipelineCodebuildRoleArn":"","pipelineProvisioningRepository":"","pipelineServiceRoleArn":""}'
};

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 = @{ @"deletePipelineProvisioningRepository": @"",
                              @"pipelineCodebuildRoleArn": @"",
                              @"pipelineProvisioningRepository": @"",
                              @"pipelineServiceRoleArn": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateAccountSettings"]
                                                       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=AwsProton20200720.UpdateAccountSettings" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"deletePipelineProvisioningRepository\": \"\",\n  \"pipelineCodebuildRoleArn\": \"\",\n  \"pipelineProvisioningRepository\": \"\",\n  \"pipelineServiceRoleArn\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateAccountSettings",
  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([
    'deletePipelineProvisioningRepository' => '',
    'pipelineCodebuildRoleArn' => '',
    'pipelineProvisioningRepository' => '',
    'pipelineServiceRoleArn' => ''
  ]),
  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=AwsProton20200720.UpdateAccountSettings', [
  'body' => '{
  "deletePipelineProvisioningRepository": "",
  "pipelineCodebuildRoleArn": "",
  "pipelineProvisioningRepository": "",
  "pipelineServiceRoleArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateAccountSettings');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'deletePipelineProvisioningRepository' => '',
  'pipelineCodebuildRoleArn' => '',
  'pipelineProvisioningRepository' => '',
  'pipelineServiceRoleArn' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'deletePipelineProvisioningRepository' => '',
  'pipelineCodebuildRoleArn' => '',
  'pipelineProvisioningRepository' => '',
  'pipelineServiceRoleArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateAccountSettings');
$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=AwsProton20200720.UpdateAccountSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "deletePipelineProvisioningRepository": "",
  "pipelineCodebuildRoleArn": "",
  "pipelineProvisioningRepository": "",
  "pipelineServiceRoleArn": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateAccountSettings' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "deletePipelineProvisioningRepository": "",
  "pipelineCodebuildRoleArn": "",
  "pipelineProvisioningRepository": "",
  "pipelineServiceRoleArn": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"deletePipelineProvisioningRepository\": \"\",\n  \"pipelineCodebuildRoleArn\": \"\",\n  \"pipelineProvisioningRepository\": \"\",\n  \"pipelineServiceRoleArn\": \"\"\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=AwsProton20200720.UpdateAccountSettings"

payload = {
    "deletePipelineProvisioningRepository": "",
    "pipelineCodebuildRoleArn": "",
    "pipelineProvisioningRepository": "",
    "pipelineServiceRoleArn": ""
}
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=AwsProton20200720.UpdateAccountSettings"

payload <- "{\n  \"deletePipelineProvisioningRepository\": \"\",\n  \"pipelineCodebuildRoleArn\": \"\",\n  \"pipelineProvisioningRepository\": \"\",\n  \"pipelineServiceRoleArn\": \"\"\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=AwsProton20200720.UpdateAccountSettings")

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  \"deletePipelineProvisioningRepository\": \"\",\n  \"pipelineCodebuildRoleArn\": \"\",\n  \"pipelineProvisioningRepository\": \"\",\n  \"pipelineServiceRoleArn\": \"\"\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  \"deletePipelineProvisioningRepository\": \"\",\n  \"pipelineCodebuildRoleArn\": \"\",\n  \"pipelineProvisioningRepository\": \"\",\n  \"pipelineServiceRoleArn\": \"\"\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=AwsProton20200720.UpdateAccountSettings";

    let payload = json!({
        "deletePipelineProvisioningRepository": "",
        "pipelineCodebuildRoleArn": "",
        "pipelineProvisioningRepository": "",
        "pipelineServiceRoleArn": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateAccountSettings' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "deletePipelineProvisioningRepository": "",
  "pipelineCodebuildRoleArn": "",
  "pipelineProvisioningRepository": "",
  "pipelineServiceRoleArn": ""
}'

echo '{
  "deletePipelineProvisioningRepository": "",
  "pipelineCodebuildRoleArn": "",
  "pipelineProvisioningRepository": "",
  "pipelineServiceRoleArn": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateAccountSettings' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "deletePipelineProvisioningRepository": "",\n  "pipelineCodebuildRoleArn": "",\n  "pipelineProvisioningRepository": "",\n  "pipelineServiceRoleArn": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateAccountSettings'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "deletePipelineProvisioningRepository": "",
  "pipelineCodebuildRoleArn": "",
  "pipelineProvisioningRepository": "",
  "pipelineServiceRoleArn": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateAccountSettings")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateComponent

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateComponent

HEADERS

X-Amz-Target

BODY json

{
  "clientToken": "",
  "deploymentType": "",
  "description": "",
  "name": "",
  "serviceInstanceName": "",
  "serviceName": "",
  "serviceSpec": "",
  "templateFile": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateComponent");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"templateFile\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateComponent" {:headers {:x-amz-target ""}
                                                                                            :content-type :json
                                                                                            :form-params {:clientToken ""
                                                                                                          :deploymentType ""
                                                                                                          :description ""
                                                                                                          :name ""
                                                                                                          :serviceInstanceName ""
                                                                                                          :serviceName ""
                                                                                                          :serviceSpec ""
                                                                                                          :templateFile ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateComponent"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"templateFile\": \"\"\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=AwsProton20200720.UpdateComponent"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"templateFile\": \"\"\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=AwsProton20200720.UpdateComponent");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"templateFile\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateComponent"

	payload := strings.NewReader("{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"templateFile\": \"\"\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: 175

{
  "clientToken": "",
  "deploymentType": "",
  "description": "",
  "name": "",
  "serviceInstanceName": "",
  "serviceName": "",
  "serviceSpec": "",
  "templateFile": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateComponent")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"templateFile\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateComponent"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"templateFile\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"templateFile\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateComponent")
  .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=AwsProton20200720.UpdateComponent")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"templateFile\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  clientToken: '',
  deploymentType: '',
  description: '',
  name: '',
  serviceInstanceName: '',
  serviceName: '',
  serviceSpec: '',
  templateFile: ''
});

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=AwsProton20200720.UpdateComponent');
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=AwsProton20200720.UpdateComponent',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    clientToken: '',
    deploymentType: '',
    description: '',
    name: '',
    serviceInstanceName: '',
    serviceName: '',
    serviceSpec: '',
    templateFile: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateComponent';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"clientToken":"","deploymentType":"","description":"","name":"","serviceInstanceName":"","serviceName":"","serviceSpec":"","templateFile":""}'
};

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=AwsProton20200720.UpdateComponent',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "clientToken": "",\n  "deploymentType": "",\n  "description": "",\n  "name": "",\n  "serviceInstanceName": "",\n  "serviceName": "",\n  "serviceSpec": "",\n  "templateFile": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"templateFile\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateComponent")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  clientToken: '',
  deploymentType: '',
  description: '',
  name: '',
  serviceInstanceName: '',
  serviceName: '',
  serviceSpec: '',
  templateFile: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateComponent',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    clientToken: '',
    deploymentType: '',
    description: '',
    name: '',
    serviceInstanceName: '',
    serviceName: '',
    serviceSpec: '',
    templateFile: ''
  },
  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=AwsProton20200720.UpdateComponent');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  clientToken: '',
  deploymentType: '',
  description: '',
  name: '',
  serviceInstanceName: '',
  serviceName: '',
  serviceSpec: '',
  templateFile: ''
});

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=AwsProton20200720.UpdateComponent',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    clientToken: '',
    deploymentType: '',
    description: '',
    name: '',
    serviceInstanceName: '',
    serviceName: '',
    serviceSpec: '',
    templateFile: ''
  }
};

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=AwsProton20200720.UpdateComponent';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"clientToken":"","deploymentType":"","description":"","name":"","serviceInstanceName":"","serviceName":"","serviceSpec":"","templateFile":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"clientToken": @"",
                              @"deploymentType": @"",
                              @"description": @"",
                              @"name": @"",
                              @"serviceInstanceName": @"",
                              @"serviceName": @"",
                              @"serviceSpec": @"",
                              @"templateFile": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateComponent"]
                                                       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=AwsProton20200720.UpdateComponent" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"templateFile\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateComponent",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'clientToken' => '',
    'deploymentType' => '',
    'description' => '',
    'name' => '',
    'serviceInstanceName' => '',
    'serviceName' => '',
    'serviceSpec' => '',
    'templateFile' => ''
  ]),
  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=AwsProton20200720.UpdateComponent', [
  'body' => '{
  "clientToken": "",
  "deploymentType": "",
  "description": "",
  "name": "",
  "serviceInstanceName": "",
  "serviceName": "",
  "serviceSpec": "",
  "templateFile": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateComponent');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'clientToken' => '',
  'deploymentType' => '',
  'description' => '',
  'name' => '',
  'serviceInstanceName' => '',
  'serviceName' => '',
  'serviceSpec' => '',
  'templateFile' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'clientToken' => '',
  'deploymentType' => '',
  'description' => '',
  'name' => '',
  'serviceInstanceName' => '',
  'serviceName' => '',
  'serviceSpec' => '',
  'templateFile' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateComponent');
$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=AwsProton20200720.UpdateComponent' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "clientToken": "",
  "deploymentType": "",
  "description": "",
  "name": "",
  "serviceInstanceName": "",
  "serviceName": "",
  "serviceSpec": "",
  "templateFile": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateComponent' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "clientToken": "",
  "deploymentType": "",
  "description": "",
  "name": "",
  "serviceInstanceName": "",
  "serviceName": "",
  "serviceSpec": "",
  "templateFile": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"templateFile\": \"\"\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=AwsProton20200720.UpdateComponent"

payload = {
    "clientToken": "",
    "deploymentType": "",
    "description": "",
    "name": "",
    "serviceInstanceName": "",
    "serviceName": "",
    "serviceSpec": "",
    "templateFile": ""
}
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=AwsProton20200720.UpdateComponent"

payload <- "{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"templateFile\": \"\"\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=AwsProton20200720.UpdateComponent")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"templateFile\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"name\": \"\",\n  \"serviceInstanceName\": \"\",\n  \"serviceName\": \"\",\n  \"serviceSpec\": \"\",\n  \"templateFile\": \"\"\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=AwsProton20200720.UpdateComponent";

    let payload = json!({
        "clientToken": "",
        "deploymentType": "",
        "description": "",
        "name": "",
        "serviceInstanceName": "",
        "serviceName": "",
        "serviceSpec": "",
        "templateFile": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateComponent' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "clientToken": "",
  "deploymentType": "",
  "description": "",
  "name": "",
  "serviceInstanceName": "",
  "serviceName": "",
  "serviceSpec": "",
  "templateFile": ""
}'

echo '{
  "clientToken": "",
  "deploymentType": "",
  "description": "",
  "name": "",
  "serviceInstanceName": "",
  "serviceName": "",
  "serviceSpec": "",
  "templateFile": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateComponent' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "clientToken": "",\n  "deploymentType": "",\n  "description": "",\n  "name": "",\n  "serviceInstanceName": "",\n  "serviceName": "",\n  "serviceSpec": "",\n  "templateFile": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateComponent'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "clientToken": "",
  "deploymentType": "",
  "description": "",
  "name": "",
  "serviceInstanceName": "",
  "serviceName": "",
  "serviceSpec": "",
  "templateFile": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateComponent")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateEnvironment

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironment

HEADERS

X-Amz-Target

BODY json

{
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "deploymentType": "",
  "description": "",
  "environmentAccountConnectionId": "",
  "name": "",
  "protonServiceRoleArn": "",
  "provisioningRepository": "",
  "spec": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironment");

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  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironment" {:headers {:x-amz-target ""}
                                                                                              :content-type :json
                                                                                              :form-params {:codebuildRoleArn ""
                                                                                                            :componentRoleArn ""
                                                                                                            :deploymentType ""
                                                                                                            :description ""
                                                                                                            :environmentAccountConnectionId ""
                                                                                                            :name ""
                                                                                                            :protonServiceRoleArn ""
                                                                                                            :provisioningRepository ""
                                                                                                            :spec ""
                                                                                                            :templateMajorVersion ""
                                                                                                            :templateMinorVersion ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironment"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\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=AwsProton20200720.UpdateEnvironment"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\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=AwsProton20200720.UpdateEnvironment");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironment"

	payload := strings.NewReader("{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 289

{
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "deploymentType": "",
  "description": "",
  "environmentAccountConnectionId": "",
  "name": "",
  "protonServiceRoleArn": "",
  "provisioningRepository": "",
  "spec": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironment")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironment"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\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  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironment")
  .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=AwsProton20200720.UpdateEnvironment")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  codebuildRoleArn: '',
  componentRoleArn: '',
  deploymentType: '',
  description: '',
  environmentAccountConnectionId: '',
  name: '',
  protonServiceRoleArn: '',
  provisioningRepository: '',
  spec: '',
  templateMajorVersion: '',
  templateMinorVersion: ''
});

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=AwsProton20200720.UpdateEnvironment');
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=AwsProton20200720.UpdateEnvironment',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    codebuildRoleArn: '',
    componentRoleArn: '',
    deploymentType: '',
    description: '',
    environmentAccountConnectionId: '',
    name: '',
    protonServiceRoleArn: '',
    provisioningRepository: '',
    spec: '',
    templateMajorVersion: '',
    templateMinorVersion: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironment';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"codebuildRoleArn":"","componentRoleArn":"","deploymentType":"","description":"","environmentAccountConnectionId":"","name":"","protonServiceRoleArn":"","provisioningRepository":"","spec":"","templateMajorVersion":"","templateMinorVersion":""}'
};

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=AwsProton20200720.UpdateEnvironment',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "codebuildRoleArn": "",\n  "componentRoleArn": "",\n  "deploymentType": "",\n  "description": "",\n  "environmentAccountConnectionId": "",\n  "name": "",\n  "protonServiceRoleArn": "",\n  "provisioningRepository": "",\n  "spec": "",\n  "templateMajorVersion": "",\n  "templateMinorVersion": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironment")
  .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({
  codebuildRoleArn: '',
  componentRoleArn: '',
  deploymentType: '',
  description: '',
  environmentAccountConnectionId: '',
  name: '',
  protonServiceRoleArn: '',
  provisioningRepository: '',
  spec: '',
  templateMajorVersion: '',
  templateMinorVersion: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironment',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    codebuildRoleArn: '',
    componentRoleArn: '',
    deploymentType: '',
    description: '',
    environmentAccountConnectionId: '',
    name: '',
    protonServiceRoleArn: '',
    provisioningRepository: '',
    spec: '',
    templateMajorVersion: '',
    templateMinorVersion: ''
  },
  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=AwsProton20200720.UpdateEnvironment');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  codebuildRoleArn: '',
  componentRoleArn: '',
  deploymentType: '',
  description: '',
  environmentAccountConnectionId: '',
  name: '',
  protonServiceRoleArn: '',
  provisioningRepository: '',
  spec: '',
  templateMajorVersion: '',
  templateMinorVersion: ''
});

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=AwsProton20200720.UpdateEnvironment',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    codebuildRoleArn: '',
    componentRoleArn: '',
    deploymentType: '',
    description: '',
    environmentAccountConnectionId: '',
    name: '',
    protonServiceRoleArn: '',
    provisioningRepository: '',
    spec: '',
    templateMajorVersion: '',
    templateMinorVersion: ''
  }
};

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=AwsProton20200720.UpdateEnvironment';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"codebuildRoleArn":"","componentRoleArn":"","deploymentType":"","description":"","environmentAccountConnectionId":"","name":"","protonServiceRoleArn":"","provisioningRepository":"","spec":"","templateMajorVersion":"","templateMinorVersion":""}'
};

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 = @{ @"codebuildRoleArn": @"",
                              @"componentRoleArn": @"",
                              @"deploymentType": @"",
                              @"description": @"",
                              @"environmentAccountConnectionId": @"",
                              @"name": @"",
                              @"protonServiceRoleArn": @"",
                              @"provisioningRepository": @"",
                              @"spec": @"",
                              @"templateMajorVersion": @"",
                              @"templateMinorVersion": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironment"]
                                                       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=AwsProton20200720.UpdateEnvironment" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironment",
  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([
    'codebuildRoleArn' => '',
    'componentRoleArn' => '',
    'deploymentType' => '',
    'description' => '',
    'environmentAccountConnectionId' => '',
    'name' => '',
    'protonServiceRoleArn' => '',
    'provisioningRepository' => '',
    'spec' => '',
    'templateMajorVersion' => '',
    'templateMinorVersion' => ''
  ]),
  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=AwsProton20200720.UpdateEnvironment', [
  'body' => '{
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "deploymentType": "",
  "description": "",
  "environmentAccountConnectionId": "",
  "name": "",
  "protonServiceRoleArn": "",
  "provisioningRepository": "",
  "spec": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironment');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'codebuildRoleArn' => '',
  'componentRoleArn' => '',
  'deploymentType' => '',
  'description' => '',
  'environmentAccountConnectionId' => '',
  'name' => '',
  'protonServiceRoleArn' => '',
  'provisioningRepository' => '',
  'spec' => '',
  'templateMajorVersion' => '',
  'templateMinorVersion' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'codebuildRoleArn' => '',
  'componentRoleArn' => '',
  'deploymentType' => '',
  'description' => '',
  'environmentAccountConnectionId' => '',
  'name' => '',
  'protonServiceRoleArn' => '',
  'provisioningRepository' => '',
  'spec' => '',
  'templateMajorVersion' => '',
  'templateMinorVersion' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironment');
$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=AwsProton20200720.UpdateEnvironment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "deploymentType": "",
  "description": "",
  "environmentAccountConnectionId": "",
  "name": "",
  "protonServiceRoleArn": "",
  "provisioningRepository": "",
  "spec": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironment' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "deploymentType": "",
  "description": "",
  "environmentAccountConnectionId": "",
  "name": "",
  "protonServiceRoleArn": "",
  "provisioningRepository": "",
  "spec": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\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=AwsProton20200720.UpdateEnvironment"

payload = {
    "codebuildRoleArn": "",
    "componentRoleArn": "",
    "deploymentType": "",
    "description": "",
    "environmentAccountConnectionId": "",
    "name": "",
    "protonServiceRoleArn": "",
    "provisioningRepository": "",
    "spec": "",
    "templateMajorVersion": "",
    "templateMinorVersion": ""
}
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=AwsProton20200720.UpdateEnvironment"

payload <- "{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\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=AwsProton20200720.UpdateEnvironment")

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  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\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  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"deploymentType\": \"\",\n  \"description\": \"\",\n  \"environmentAccountConnectionId\": \"\",\n  \"name\": \"\",\n  \"protonServiceRoleArn\": \"\",\n  \"provisioningRepository\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\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=AwsProton20200720.UpdateEnvironment";

    let payload = json!({
        "codebuildRoleArn": "",
        "componentRoleArn": "",
        "deploymentType": "",
        "description": "",
        "environmentAccountConnectionId": "",
        "name": "",
        "protonServiceRoleArn": "",
        "provisioningRepository": "",
        "spec": "",
        "templateMajorVersion": "",
        "templateMinorVersion": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironment' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "deploymentType": "",
  "description": "",
  "environmentAccountConnectionId": "",
  "name": "",
  "protonServiceRoleArn": "",
  "provisioningRepository": "",
  "spec": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}'

echo '{
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "deploymentType": "",
  "description": "",
  "environmentAccountConnectionId": "",
  "name": "",
  "protonServiceRoleArn": "",
  "provisioningRepository": "",
  "spec": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironment' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "codebuildRoleArn": "",\n  "componentRoleArn": "",\n  "deploymentType": "",\n  "description": "",\n  "environmentAccountConnectionId": "",\n  "name": "",\n  "protonServiceRoleArn": "",\n  "provisioningRepository": "",\n  "spec": "",\n  "templateMajorVersion": "",\n  "templateMinorVersion": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironment'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "deploymentType": "",
  "description": "",
  "environmentAccountConnectionId": "",
  "name": "",
  "protonServiceRoleArn": "",
  "provisioningRepository": "",
  "spec": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironment")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateEnvironmentAccountConnection

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentAccountConnection

HEADERS

X-Amz-Target

BODY json

{
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "id": "",
  "roleArn": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentAccountConnection");

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  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"id\": \"\",\n  \"roleArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentAccountConnection" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:codebuildRoleArn ""
                                                                                                                             :componentRoleArn ""
                                                                                                                             :id ""
                                                                                                                             :roleArn ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentAccountConnection"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"id\": \"\",\n  \"roleArn\": \"\"\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=AwsProton20200720.UpdateEnvironmentAccountConnection"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"id\": \"\",\n  \"roleArn\": \"\"\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=AwsProton20200720.UpdateEnvironmentAccountConnection");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"id\": \"\",\n  \"roleArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentAccountConnection"

	payload := strings.NewReader("{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"id\": \"\",\n  \"roleArn\": \"\"\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: 83

{
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "id": "",
  "roleArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentAccountConnection")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"id\": \"\",\n  \"roleArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentAccountConnection"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"id\": \"\",\n  \"roleArn\": \"\"\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  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"id\": \"\",\n  \"roleArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentAccountConnection")
  .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=AwsProton20200720.UpdateEnvironmentAccountConnection")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"id\": \"\",\n  \"roleArn\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  codebuildRoleArn: '',
  componentRoleArn: '',
  id: '',
  roleArn: ''
});

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=AwsProton20200720.UpdateEnvironmentAccountConnection');
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=AwsProton20200720.UpdateEnvironmentAccountConnection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {codebuildRoleArn: '', componentRoleArn: '', id: '', roleArn: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentAccountConnection';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"codebuildRoleArn":"","componentRoleArn":"","id":"","roleArn":""}'
};

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=AwsProton20200720.UpdateEnvironmentAccountConnection',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "codebuildRoleArn": "",\n  "componentRoleArn": "",\n  "id": "",\n  "roleArn": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"id\": \"\",\n  \"roleArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentAccountConnection")
  .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({codebuildRoleArn: '', componentRoleArn: '', id: '', roleArn: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentAccountConnection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {codebuildRoleArn: '', componentRoleArn: '', id: '', roleArn: ''},
  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=AwsProton20200720.UpdateEnvironmentAccountConnection');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  codebuildRoleArn: '',
  componentRoleArn: '',
  id: '',
  roleArn: ''
});

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=AwsProton20200720.UpdateEnvironmentAccountConnection',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {codebuildRoleArn: '', componentRoleArn: '', id: '', roleArn: ''}
};

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=AwsProton20200720.UpdateEnvironmentAccountConnection';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"codebuildRoleArn":"","componentRoleArn":"","id":"","roleArn":""}'
};

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 = @{ @"codebuildRoleArn": @"",
                              @"componentRoleArn": @"",
                              @"id": @"",
                              @"roleArn": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentAccountConnection"]
                                                       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=AwsProton20200720.UpdateEnvironmentAccountConnection" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"id\": \"\",\n  \"roleArn\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentAccountConnection",
  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([
    'codebuildRoleArn' => '',
    'componentRoleArn' => '',
    'id' => '',
    'roleArn' => ''
  ]),
  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=AwsProton20200720.UpdateEnvironmentAccountConnection', [
  'body' => '{
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "id": "",
  "roleArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentAccountConnection');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'codebuildRoleArn' => '',
  'componentRoleArn' => '',
  'id' => '',
  'roleArn' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'codebuildRoleArn' => '',
  'componentRoleArn' => '',
  'id' => '',
  'roleArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentAccountConnection');
$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=AwsProton20200720.UpdateEnvironmentAccountConnection' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "id": "",
  "roleArn": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentAccountConnection' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "id": "",
  "roleArn": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"id\": \"\",\n  \"roleArn\": \"\"\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=AwsProton20200720.UpdateEnvironmentAccountConnection"

payload = {
    "codebuildRoleArn": "",
    "componentRoleArn": "",
    "id": "",
    "roleArn": ""
}
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=AwsProton20200720.UpdateEnvironmentAccountConnection"

payload <- "{\n  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"id\": \"\",\n  \"roleArn\": \"\"\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=AwsProton20200720.UpdateEnvironmentAccountConnection")

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  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"id\": \"\",\n  \"roleArn\": \"\"\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  \"codebuildRoleArn\": \"\",\n  \"componentRoleArn\": \"\",\n  \"id\": \"\",\n  \"roleArn\": \"\"\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=AwsProton20200720.UpdateEnvironmentAccountConnection";

    let payload = json!({
        "codebuildRoleArn": "",
        "componentRoleArn": "",
        "id": "",
        "roleArn": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentAccountConnection' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "id": "",
  "roleArn": ""
}'

echo '{
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "id": "",
  "roleArn": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentAccountConnection' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "codebuildRoleArn": "",\n  "componentRoleArn": "",\n  "id": "",\n  "roleArn": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentAccountConnection'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "codebuildRoleArn": "",
  "componentRoleArn": "",
  "id": "",
  "roleArn": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentAccountConnection")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateEnvironmentTemplate

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate

HEADERS

X-Amz-Target

BODY json

{
  "description": "",
  "displayName": "",
  "name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate");

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  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:description ""
                                                                                                                    :displayName ""
                                                                                                                    :name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate"

	payload := strings.NewReader("{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 58

{
  "description": "",
  "displayName": "",
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate")
  .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=AwsProton20200720.UpdateEnvironmentTemplate")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  description: '',
  displayName: '',
  name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate');
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=AwsProton20200720.UpdateEnvironmentTemplate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {description: '', displayName: '', name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"description":"","displayName":"","name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "description": "",\n  "displayName": "",\n  "name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate")
  .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({description: '', displayName: '', name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {description: '', displayName: '', name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  description: '',
  displayName: '',
  name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {description: '', displayName: '', name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"description":"","displayName":"","name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"description": @"",
                              @"displayName": @"",
                              @"name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate"]
                                                       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=AwsProton20200720.UpdateEnvironmentTemplate" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate",
  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([
    'description' => '',
    'displayName' => '',
    'name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate', [
  'body' => '{
  "description": "",
  "displayName": "",
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'description' => '',
  'displayName' => '',
  'name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'description' => '',
  'displayName' => '',
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate');
$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=AwsProton20200720.UpdateEnvironmentTemplate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "displayName": "",
  "name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "displayName": "",
  "name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate"

payload = {
    "description": "",
    "displayName": "",
    "name": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate"

payload <- "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate")

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  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate";

    let payload = json!({
        "description": "",
        "displayName": "",
        "name": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "description": "",
  "displayName": "",
  "name": ""
}'

echo '{
  "description": "",
  "displayName": "",
  "name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "description": "",\n  "displayName": "",\n  "name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "description": "",
  "displayName": "",
  "name": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateEnvironmentTemplateVersion

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplateVersion

HEADERS

X-Amz-Target

BODY json

{
  "description": "",
  "majorVersion": "",
  "minorVersion": "",
  "status": "",
  "templateName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplateVersion");

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  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"templateName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplateVersion" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:description ""
                                                                                                                           :majorVersion ""
                                                                                                                           :minorVersion ""
                                                                                                                           :status ""
                                                                                                                           :templateName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplateVersion"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.UpdateEnvironmentTemplateVersion"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.UpdateEnvironmentTemplateVersion");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"templateName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplateVersion"

	payload := strings.NewReader("{\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"templateName\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 105

{
  "description": "",
  "majorVersion": "",
  "minorVersion": "",
  "status": "",
  "templateName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplateVersion")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"templateName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplateVersion"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"templateName\": \"\"\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  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"templateName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplateVersion")
  .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=AwsProton20200720.UpdateEnvironmentTemplateVersion")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"templateName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  description: '',
  majorVersion: '',
  minorVersion: '',
  status: '',
  templateName: ''
});

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=AwsProton20200720.UpdateEnvironmentTemplateVersion');
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=AwsProton20200720.UpdateEnvironmentTemplateVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    description: '',
    majorVersion: '',
    minorVersion: '',
    status: '',
    templateName: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplateVersion';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"description":"","majorVersion":"","minorVersion":"","status":"","templateName":""}'
};

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=AwsProton20200720.UpdateEnvironmentTemplateVersion',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "description": "",\n  "majorVersion": "",\n  "minorVersion": "",\n  "status": "",\n  "templateName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"templateName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplateVersion")
  .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({
  description: '',
  majorVersion: '',
  minorVersion: '',
  status: '',
  templateName: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplateVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    description: '',
    majorVersion: '',
    minorVersion: '',
    status: '',
    templateName: ''
  },
  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=AwsProton20200720.UpdateEnvironmentTemplateVersion');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  description: '',
  majorVersion: '',
  minorVersion: '',
  status: '',
  templateName: ''
});

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=AwsProton20200720.UpdateEnvironmentTemplateVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    description: '',
    majorVersion: '',
    minorVersion: '',
    status: '',
    templateName: ''
  }
};

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=AwsProton20200720.UpdateEnvironmentTemplateVersion';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"description":"","majorVersion":"","minorVersion":"","status":"","templateName":""}'
};

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 = @{ @"description": @"",
                              @"majorVersion": @"",
                              @"minorVersion": @"",
                              @"status": @"",
                              @"templateName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplateVersion"]
                                                       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=AwsProton20200720.UpdateEnvironmentTemplateVersion" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"templateName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplateVersion",
  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([
    'description' => '',
    'majorVersion' => '',
    'minorVersion' => '',
    'status' => '',
    'templateName' => ''
  ]),
  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=AwsProton20200720.UpdateEnvironmentTemplateVersion', [
  'body' => '{
  "description": "",
  "majorVersion": "",
  "minorVersion": "",
  "status": "",
  "templateName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplateVersion');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'description' => '',
  'majorVersion' => '',
  'minorVersion' => '',
  'status' => '',
  'templateName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'description' => '',
  'majorVersion' => '',
  'minorVersion' => '',
  'status' => '',
  'templateName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplateVersion');
$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=AwsProton20200720.UpdateEnvironmentTemplateVersion' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "majorVersion": "",
  "minorVersion": "",
  "status": "",
  "templateName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplateVersion' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "majorVersion": "",
  "minorVersion": "",
  "status": "",
  "templateName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.UpdateEnvironmentTemplateVersion"

payload = {
    "description": "",
    "majorVersion": "",
    "minorVersion": "",
    "status": "",
    "templateName": ""
}
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=AwsProton20200720.UpdateEnvironmentTemplateVersion"

payload <- "{\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.UpdateEnvironmentTemplateVersion")

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  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"templateName\": \"\"\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  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.UpdateEnvironmentTemplateVersion";

    let payload = json!({
        "description": "",
        "majorVersion": "",
        "minorVersion": "",
        "status": "",
        "templateName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplateVersion' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "description": "",
  "majorVersion": "",
  "minorVersion": "",
  "status": "",
  "templateName": ""
}'

echo '{
  "description": "",
  "majorVersion": "",
  "minorVersion": "",
  "status": "",
  "templateName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplateVersion' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "description": "",\n  "majorVersion": "",\n  "minorVersion": "",\n  "status": "",\n  "templateName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplateVersion'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "description": "",
  "majorVersion": "",
  "minorVersion": "",
  "status": "",
  "templateName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateEnvironmentTemplateVersion")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateService

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateService

HEADERS

X-Amz-Target

BODY json

{
  "description": "",
  "name": "",
  "spec": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateService");

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  \"description\": \"\",\n  \"name\": \"\",\n  \"spec\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateService" {:headers {:x-amz-target ""}
                                                                                          :content-type :json
                                                                                          :form-params {:description ""
                                                                                                        :name ""
                                                                                                        :spec ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateService"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"description\": \"\",\n  \"name\": \"\",\n  \"spec\": \"\"\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=AwsProton20200720.UpdateService"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"description\": \"\",\n  \"name\": \"\",\n  \"spec\": \"\"\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=AwsProton20200720.UpdateService");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"description\": \"\",\n  \"name\": \"\",\n  \"spec\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateService"

	payload := strings.NewReader("{\n  \"description\": \"\",\n  \"name\": \"\",\n  \"spec\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 51

{
  "description": "",
  "name": "",
  "spec": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateService")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"description\": \"\",\n  \"name\": \"\",\n  \"spec\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateService"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"description\": \"\",\n  \"name\": \"\",\n  \"spec\": \"\"\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  \"description\": \"\",\n  \"name\": \"\",\n  \"spec\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateService")
  .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=AwsProton20200720.UpdateService")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"description\": \"\",\n  \"name\": \"\",\n  \"spec\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  description: '',
  name: '',
  spec: ''
});

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=AwsProton20200720.UpdateService');
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=AwsProton20200720.UpdateService',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {description: '', name: '', spec: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateService';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"description":"","name":"","spec":""}'
};

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=AwsProton20200720.UpdateService',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "description": "",\n  "name": "",\n  "spec": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"name\": \"\",\n  \"spec\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateService")
  .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({description: '', name: '', spec: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateService',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {description: '', name: '', spec: ''},
  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=AwsProton20200720.UpdateService');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  description: '',
  name: '',
  spec: ''
});

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=AwsProton20200720.UpdateService',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {description: '', name: '', spec: ''}
};

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=AwsProton20200720.UpdateService';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"description":"","name":"","spec":""}'
};

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 = @{ @"description": @"",
                              @"name": @"",
                              @"spec": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateService"]
                                                       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=AwsProton20200720.UpdateService" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"description\": \"\",\n  \"name\": \"\",\n  \"spec\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateService",
  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([
    'description' => '',
    'name' => '',
    'spec' => ''
  ]),
  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=AwsProton20200720.UpdateService', [
  'body' => '{
  "description": "",
  "name": "",
  "spec": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateService');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'description' => '',
  'name' => '',
  'spec' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'description' => '',
  'name' => '',
  'spec' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateService');
$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=AwsProton20200720.UpdateService' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "name": "",
  "spec": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateService' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "name": "",
  "spec": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"description\": \"\",\n  \"name\": \"\",\n  \"spec\": \"\"\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=AwsProton20200720.UpdateService"

payload = {
    "description": "",
    "name": "",
    "spec": ""
}
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=AwsProton20200720.UpdateService"

payload <- "{\n  \"description\": \"\",\n  \"name\": \"\",\n  \"spec\": \"\"\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=AwsProton20200720.UpdateService")

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  \"description\": \"\",\n  \"name\": \"\",\n  \"spec\": \"\"\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  \"description\": \"\",\n  \"name\": \"\",\n  \"spec\": \"\"\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=AwsProton20200720.UpdateService";

    let payload = json!({
        "description": "",
        "name": "",
        "spec": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateService' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "description": "",
  "name": "",
  "spec": ""
}'

echo '{
  "description": "",
  "name": "",
  "spec": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateService' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "description": "",\n  "name": "",\n  "spec": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateService'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "description": "",
  "name": "",
  "spec": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateService")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateServiceInstance

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceInstance

HEADERS

X-Amz-Target

BODY json

{
  "clientToken": "",
  "deploymentType": "",
  "name": "",
  "serviceName": "",
  "spec": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceInstance");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"name\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceInstance" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:clientToken ""
                                                                                                                :deploymentType ""
                                                                                                                :name ""
                                                                                                                :serviceName ""
                                                                                                                :spec ""
                                                                                                                :templateMajorVersion ""
                                                                                                                :templateMinorVersion ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceInstance"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"name\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\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=AwsProton20200720.UpdateServiceInstance"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"name\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\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=AwsProton20200720.UpdateServiceInstance");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"name\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceInstance"

	payload := strings.NewReader("{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"name\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\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: 156

{
  "clientToken": "",
  "deploymentType": "",
  "name": "",
  "serviceName": "",
  "spec": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceInstance")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"name\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceInstance"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"name\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"name\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceInstance")
  .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=AwsProton20200720.UpdateServiceInstance")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"name\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  clientToken: '',
  deploymentType: '',
  name: '',
  serviceName: '',
  spec: '',
  templateMajorVersion: '',
  templateMinorVersion: ''
});

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=AwsProton20200720.UpdateServiceInstance');
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=AwsProton20200720.UpdateServiceInstance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    clientToken: '',
    deploymentType: '',
    name: '',
    serviceName: '',
    spec: '',
    templateMajorVersion: '',
    templateMinorVersion: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceInstance';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"clientToken":"","deploymentType":"","name":"","serviceName":"","spec":"","templateMajorVersion":"","templateMinorVersion":""}'
};

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=AwsProton20200720.UpdateServiceInstance',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "clientToken": "",\n  "deploymentType": "",\n  "name": "",\n  "serviceName": "",\n  "spec": "",\n  "templateMajorVersion": "",\n  "templateMinorVersion": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"name\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceInstance")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  clientToken: '',
  deploymentType: '',
  name: '',
  serviceName: '',
  spec: '',
  templateMajorVersion: '',
  templateMinorVersion: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceInstance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    clientToken: '',
    deploymentType: '',
    name: '',
    serviceName: '',
    spec: '',
    templateMajorVersion: '',
    templateMinorVersion: ''
  },
  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=AwsProton20200720.UpdateServiceInstance');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  clientToken: '',
  deploymentType: '',
  name: '',
  serviceName: '',
  spec: '',
  templateMajorVersion: '',
  templateMinorVersion: ''
});

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=AwsProton20200720.UpdateServiceInstance',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    clientToken: '',
    deploymentType: '',
    name: '',
    serviceName: '',
    spec: '',
    templateMajorVersion: '',
    templateMinorVersion: ''
  }
};

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=AwsProton20200720.UpdateServiceInstance';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"clientToken":"","deploymentType":"","name":"","serviceName":"","spec":"","templateMajorVersion":"","templateMinorVersion":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"clientToken": @"",
                              @"deploymentType": @"",
                              @"name": @"",
                              @"serviceName": @"",
                              @"spec": @"",
                              @"templateMajorVersion": @"",
                              @"templateMinorVersion": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceInstance"]
                                                       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=AwsProton20200720.UpdateServiceInstance" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"name\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceInstance",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'clientToken' => '',
    'deploymentType' => '',
    'name' => '',
    'serviceName' => '',
    'spec' => '',
    'templateMajorVersion' => '',
    'templateMinorVersion' => ''
  ]),
  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=AwsProton20200720.UpdateServiceInstance', [
  'body' => '{
  "clientToken": "",
  "deploymentType": "",
  "name": "",
  "serviceName": "",
  "spec": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceInstance');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'clientToken' => '',
  'deploymentType' => '',
  'name' => '',
  'serviceName' => '',
  'spec' => '',
  'templateMajorVersion' => '',
  'templateMinorVersion' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'clientToken' => '',
  'deploymentType' => '',
  'name' => '',
  'serviceName' => '',
  'spec' => '',
  'templateMajorVersion' => '',
  'templateMinorVersion' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceInstance');
$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=AwsProton20200720.UpdateServiceInstance' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "clientToken": "",
  "deploymentType": "",
  "name": "",
  "serviceName": "",
  "spec": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceInstance' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "clientToken": "",
  "deploymentType": "",
  "name": "",
  "serviceName": "",
  "spec": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"name\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\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=AwsProton20200720.UpdateServiceInstance"

payload = {
    "clientToken": "",
    "deploymentType": "",
    "name": "",
    "serviceName": "",
    "spec": "",
    "templateMajorVersion": "",
    "templateMinorVersion": ""
}
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=AwsProton20200720.UpdateServiceInstance"

payload <- "{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"name\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\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=AwsProton20200720.UpdateServiceInstance")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"name\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"clientToken\": \"\",\n  \"deploymentType\": \"\",\n  \"name\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\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=AwsProton20200720.UpdateServiceInstance";

    let payload = json!({
        "clientToken": "",
        "deploymentType": "",
        "name": "",
        "serviceName": "",
        "spec": "",
        "templateMajorVersion": "",
        "templateMinorVersion": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceInstance' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "clientToken": "",
  "deploymentType": "",
  "name": "",
  "serviceName": "",
  "spec": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}'

echo '{
  "clientToken": "",
  "deploymentType": "",
  "name": "",
  "serviceName": "",
  "spec": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceInstance' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "clientToken": "",\n  "deploymentType": "",\n  "name": "",\n  "serviceName": "",\n  "spec": "",\n  "templateMajorVersion": "",\n  "templateMinorVersion": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceInstance'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "clientToken": "",
  "deploymentType": "",
  "name": "",
  "serviceName": "",
  "spec": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceInstance")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateServicePipeline

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServicePipeline

HEADERS

X-Amz-Target

BODY json

{
  "deploymentType": "",
  "serviceName": "",
  "spec": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServicePipeline");

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  \"deploymentType\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServicePipeline" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:deploymentType ""
                                                                                                                :serviceName ""
                                                                                                                :spec ""
                                                                                                                :templateMajorVersion ""
                                                                                                                :templateMinorVersion ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServicePipeline"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"deploymentType\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\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=AwsProton20200720.UpdateServicePipeline"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"deploymentType\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\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=AwsProton20200720.UpdateServicePipeline");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"deploymentType\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServicePipeline"

	payload := strings.NewReader("{\n  \"deploymentType\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\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: 121

{
  "deploymentType": "",
  "serviceName": "",
  "spec": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServicePipeline")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"deploymentType\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServicePipeline"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"deploymentType\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\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  \"deploymentType\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServicePipeline")
  .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=AwsProton20200720.UpdateServicePipeline")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"deploymentType\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  deploymentType: '',
  serviceName: '',
  spec: '',
  templateMajorVersion: '',
  templateMinorVersion: ''
});

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=AwsProton20200720.UpdateServicePipeline');
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=AwsProton20200720.UpdateServicePipeline',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    deploymentType: '',
    serviceName: '',
    spec: '',
    templateMajorVersion: '',
    templateMinorVersion: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServicePipeline';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"deploymentType":"","serviceName":"","spec":"","templateMajorVersion":"","templateMinorVersion":""}'
};

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=AwsProton20200720.UpdateServicePipeline',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "deploymentType": "",\n  "serviceName": "",\n  "spec": "",\n  "templateMajorVersion": "",\n  "templateMinorVersion": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"deploymentType\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServicePipeline")
  .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({
  deploymentType: '',
  serviceName: '',
  spec: '',
  templateMajorVersion: '',
  templateMinorVersion: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServicePipeline',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    deploymentType: '',
    serviceName: '',
    spec: '',
    templateMajorVersion: '',
    templateMinorVersion: ''
  },
  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=AwsProton20200720.UpdateServicePipeline');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  deploymentType: '',
  serviceName: '',
  spec: '',
  templateMajorVersion: '',
  templateMinorVersion: ''
});

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=AwsProton20200720.UpdateServicePipeline',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    deploymentType: '',
    serviceName: '',
    spec: '',
    templateMajorVersion: '',
    templateMinorVersion: ''
  }
};

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=AwsProton20200720.UpdateServicePipeline';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"deploymentType":"","serviceName":"","spec":"","templateMajorVersion":"","templateMinorVersion":""}'
};

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 = @{ @"deploymentType": @"",
                              @"serviceName": @"",
                              @"spec": @"",
                              @"templateMajorVersion": @"",
                              @"templateMinorVersion": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServicePipeline"]
                                                       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=AwsProton20200720.UpdateServicePipeline" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"deploymentType\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServicePipeline",
  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([
    'deploymentType' => '',
    'serviceName' => '',
    'spec' => '',
    'templateMajorVersion' => '',
    'templateMinorVersion' => ''
  ]),
  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=AwsProton20200720.UpdateServicePipeline', [
  'body' => '{
  "deploymentType": "",
  "serviceName": "",
  "spec": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServicePipeline');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'deploymentType' => '',
  'serviceName' => '',
  'spec' => '',
  'templateMajorVersion' => '',
  'templateMinorVersion' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'deploymentType' => '',
  'serviceName' => '',
  'spec' => '',
  'templateMajorVersion' => '',
  'templateMinorVersion' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServicePipeline');
$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=AwsProton20200720.UpdateServicePipeline' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "deploymentType": "",
  "serviceName": "",
  "spec": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServicePipeline' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "deploymentType": "",
  "serviceName": "",
  "spec": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"deploymentType\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\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=AwsProton20200720.UpdateServicePipeline"

payload = {
    "deploymentType": "",
    "serviceName": "",
    "spec": "",
    "templateMajorVersion": "",
    "templateMinorVersion": ""
}
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=AwsProton20200720.UpdateServicePipeline"

payload <- "{\n  \"deploymentType\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\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=AwsProton20200720.UpdateServicePipeline")

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  \"deploymentType\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\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  \"deploymentType\": \"\",\n  \"serviceName\": \"\",\n  \"spec\": \"\",\n  \"templateMajorVersion\": \"\",\n  \"templateMinorVersion\": \"\"\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=AwsProton20200720.UpdateServicePipeline";

    let payload = json!({
        "deploymentType": "",
        "serviceName": "",
        "spec": "",
        "templateMajorVersion": "",
        "templateMinorVersion": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServicePipeline' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "deploymentType": "",
  "serviceName": "",
  "spec": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}'

echo '{
  "deploymentType": "",
  "serviceName": "",
  "spec": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServicePipeline' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "deploymentType": "",\n  "serviceName": "",\n  "spec": "",\n  "templateMajorVersion": "",\n  "templateMinorVersion": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServicePipeline'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "deploymentType": "",
  "serviceName": "",
  "spec": "",
  "templateMajorVersion": "",
  "templateMinorVersion": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServicePipeline")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateServiceSyncBlocker

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncBlocker

HEADERS

X-Amz-Target

BODY json

{
  "id": "",
  "resolvedReason": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncBlocker");

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  \"id\": \"\",\n  \"resolvedReason\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncBlocker" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:id ""
                                                                                                                   :resolvedReason ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncBlocker"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"id\": \"\",\n  \"resolvedReason\": \"\"\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=AwsProton20200720.UpdateServiceSyncBlocker"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"id\": \"\",\n  \"resolvedReason\": \"\"\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=AwsProton20200720.UpdateServiceSyncBlocker");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"id\": \"\",\n  \"resolvedReason\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncBlocker"

	payload := strings.NewReader("{\n  \"id\": \"\",\n  \"resolvedReason\": \"\"\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: 38

{
  "id": "",
  "resolvedReason": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncBlocker")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"id\": \"\",\n  \"resolvedReason\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncBlocker"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"id\": \"\",\n  \"resolvedReason\": \"\"\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  \"id\": \"\",\n  \"resolvedReason\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncBlocker")
  .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=AwsProton20200720.UpdateServiceSyncBlocker")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"id\": \"\",\n  \"resolvedReason\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  id: '',
  resolvedReason: ''
});

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=AwsProton20200720.UpdateServiceSyncBlocker');
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=AwsProton20200720.UpdateServiceSyncBlocker',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {id: '', resolvedReason: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncBlocker';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"id":"","resolvedReason":""}'
};

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=AwsProton20200720.UpdateServiceSyncBlocker',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "id": "",\n  "resolvedReason": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"id\": \"\",\n  \"resolvedReason\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncBlocker")
  .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({id: '', resolvedReason: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncBlocker',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {id: '', resolvedReason: ''},
  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=AwsProton20200720.UpdateServiceSyncBlocker');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  id: '',
  resolvedReason: ''
});

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=AwsProton20200720.UpdateServiceSyncBlocker',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {id: '', resolvedReason: ''}
};

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=AwsProton20200720.UpdateServiceSyncBlocker';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"id":"","resolvedReason":""}'
};

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 = @{ @"id": @"",
                              @"resolvedReason": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncBlocker"]
                                                       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=AwsProton20200720.UpdateServiceSyncBlocker" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"id\": \"\",\n  \"resolvedReason\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncBlocker",
  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([
    'id' => '',
    'resolvedReason' => ''
  ]),
  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=AwsProton20200720.UpdateServiceSyncBlocker', [
  'body' => '{
  "id": "",
  "resolvedReason": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncBlocker');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'id' => '',
  'resolvedReason' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'id' => '',
  'resolvedReason' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncBlocker');
$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=AwsProton20200720.UpdateServiceSyncBlocker' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "resolvedReason": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncBlocker' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "id": "",
  "resolvedReason": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"id\": \"\",\n  \"resolvedReason\": \"\"\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=AwsProton20200720.UpdateServiceSyncBlocker"

payload = {
    "id": "",
    "resolvedReason": ""
}
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=AwsProton20200720.UpdateServiceSyncBlocker"

payload <- "{\n  \"id\": \"\",\n  \"resolvedReason\": \"\"\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=AwsProton20200720.UpdateServiceSyncBlocker")

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  \"id\": \"\",\n  \"resolvedReason\": \"\"\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  \"id\": \"\",\n  \"resolvedReason\": \"\"\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=AwsProton20200720.UpdateServiceSyncBlocker";

    let payload = json!({
        "id": "",
        "resolvedReason": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncBlocker' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "id": "",
  "resolvedReason": ""
}'

echo '{
  "id": "",
  "resolvedReason": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncBlocker' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "id": "",\n  "resolvedReason": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncBlocker'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "id": "",
  "resolvedReason": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncBlocker")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateServiceSyncConfig

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncConfig

HEADERS

X-Amz-Target

BODY json

{
  "branch": "",
  "filePath": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "serviceName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncConfig");

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  \"branch\": \"\",\n  \"filePath\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"serviceName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncConfig" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:branch ""
                                                                                                                  :filePath ""
                                                                                                                  :repositoryName ""
                                                                                                                  :repositoryProvider ""
                                                                                                                  :serviceName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncConfig"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"branch\": \"\",\n  \"filePath\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.UpdateServiceSyncConfig"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"branch\": \"\",\n  \"filePath\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.UpdateServiceSyncConfig");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"branch\": \"\",\n  \"filePath\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"serviceName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncConfig"

	payload := strings.NewReader("{\n  \"branch\": \"\",\n  \"filePath\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"serviceName\": \"\"\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: 109

{
  "branch": "",
  "filePath": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "serviceName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncConfig")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"branch\": \"\",\n  \"filePath\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"serviceName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncConfig"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"branch\": \"\",\n  \"filePath\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"serviceName\": \"\"\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  \"branch\": \"\",\n  \"filePath\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"serviceName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncConfig")
  .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=AwsProton20200720.UpdateServiceSyncConfig")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"branch\": \"\",\n  \"filePath\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"serviceName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  branch: '',
  filePath: '',
  repositoryName: '',
  repositoryProvider: '',
  serviceName: ''
});

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=AwsProton20200720.UpdateServiceSyncConfig');
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=AwsProton20200720.UpdateServiceSyncConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    branch: '',
    filePath: '',
    repositoryName: '',
    repositoryProvider: '',
    serviceName: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"branch":"","filePath":"","repositoryName":"","repositoryProvider":"","serviceName":""}'
};

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=AwsProton20200720.UpdateServiceSyncConfig',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "branch": "",\n  "filePath": "",\n  "repositoryName": "",\n  "repositoryProvider": "",\n  "serviceName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"branch\": \"\",\n  \"filePath\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"serviceName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncConfig")
  .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({
  branch: '',
  filePath: '',
  repositoryName: '',
  repositoryProvider: '',
  serviceName: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    branch: '',
    filePath: '',
    repositoryName: '',
    repositoryProvider: '',
    serviceName: ''
  },
  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=AwsProton20200720.UpdateServiceSyncConfig');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  branch: '',
  filePath: '',
  repositoryName: '',
  repositoryProvider: '',
  serviceName: ''
});

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=AwsProton20200720.UpdateServiceSyncConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    branch: '',
    filePath: '',
    repositoryName: '',
    repositoryProvider: '',
    serviceName: ''
  }
};

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=AwsProton20200720.UpdateServiceSyncConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"branch":"","filePath":"","repositoryName":"","repositoryProvider":"","serviceName":""}'
};

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 = @{ @"branch": @"",
                              @"filePath": @"",
                              @"repositoryName": @"",
                              @"repositoryProvider": @"",
                              @"serviceName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncConfig"]
                                                       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=AwsProton20200720.UpdateServiceSyncConfig" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"branch\": \"\",\n  \"filePath\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"serviceName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncConfig",
  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([
    'branch' => '',
    'filePath' => '',
    'repositoryName' => '',
    'repositoryProvider' => '',
    'serviceName' => ''
  ]),
  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=AwsProton20200720.UpdateServiceSyncConfig', [
  'body' => '{
  "branch": "",
  "filePath": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "serviceName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncConfig');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'branch' => '',
  'filePath' => '',
  'repositoryName' => '',
  'repositoryProvider' => '',
  'serviceName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'branch' => '',
  'filePath' => '',
  'repositoryName' => '',
  'repositoryProvider' => '',
  'serviceName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncConfig');
$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=AwsProton20200720.UpdateServiceSyncConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "branch": "",
  "filePath": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "serviceName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "branch": "",
  "filePath": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "serviceName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"branch\": \"\",\n  \"filePath\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.UpdateServiceSyncConfig"

payload = {
    "branch": "",
    "filePath": "",
    "repositoryName": "",
    "repositoryProvider": "",
    "serviceName": ""
}
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=AwsProton20200720.UpdateServiceSyncConfig"

payload <- "{\n  \"branch\": \"\",\n  \"filePath\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.UpdateServiceSyncConfig")

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  \"branch\": \"\",\n  \"filePath\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"serviceName\": \"\"\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  \"branch\": \"\",\n  \"filePath\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"serviceName\": \"\"\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=AwsProton20200720.UpdateServiceSyncConfig";

    let payload = json!({
        "branch": "",
        "filePath": "",
        "repositoryName": "",
        "repositoryProvider": "",
        "serviceName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncConfig' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "branch": "",
  "filePath": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "serviceName": ""
}'

echo '{
  "branch": "",
  "filePath": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "serviceName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncConfig' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "branch": "",\n  "filePath": "",\n  "repositoryName": "",\n  "repositoryProvider": "",\n  "serviceName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncConfig'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "branch": "",
  "filePath": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "serviceName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceSyncConfig")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateServiceTemplate

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate

HEADERS

X-Amz-Target

BODY json

{
  "description": "",
  "displayName": "",
  "name": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate");

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  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:description ""
                                                                                                                :displayName ""
                                                                                                                :name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate"

	payload := strings.NewReader("{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 58

{
  "description": "",
  "displayName": "",
  "name": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate")
  .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=AwsProton20200720.UpdateServiceTemplate")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  description: '',
  displayName: '',
  name: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate');
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=AwsProton20200720.UpdateServiceTemplate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {description: '', displayName: '', name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"description":"","displayName":"","name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "description": "",\n  "displayName": "",\n  "name": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate")
  .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({description: '', displayName: '', name: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {description: '', displayName: '', name: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  description: '',
  displayName: '',
  name: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {description: '', displayName: '', name: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"description":"","displayName":"","name":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"description": @"",
                              @"displayName": @"",
                              @"name": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate"]
                                                       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=AwsProton20200720.UpdateServiceTemplate" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate",
  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([
    'description' => '',
    'displayName' => '',
    'name' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate', [
  'body' => '{
  "description": "",
  "displayName": "",
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'description' => '',
  'displayName' => '',
  'name' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'description' => '',
  'displayName' => '',
  'name' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate');
$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=AwsProton20200720.UpdateServiceTemplate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "displayName": "",
  "name": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "description": "",
  "displayName": "",
  "name": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate"

payload = {
    "description": "",
    "displayName": "",
    "name": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate"

payload <- "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate")

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  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"description\": \"\",\n  \"displayName\": \"\",\n  \"name\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate";

    let payload = json!({
        "description": "",
        "displayName": "",
        "name": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "description": "",
  "displayName": "",
  "name": ""
}'

echo '{
  "description": "",
  "displayName": "",
  "name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "description": "",\n  "displayName": "",\n  "name": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "description": "",
  "displayName": "",
  "name": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateServiceTemplateVersion

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplateVersion

HEADERS

X-Amz-Target

BODY json

{
  "compatibleEnvironmentTemplates": "",
  "description": "",
  "majorVersion": "",
  "minorVersion": "",
  "status": "",
  "supportedComponentSources": "",
  "templateName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplateVersion");

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  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"templateName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplateVersion" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:compatibleEnvironmentTemplates ""
                                                                                                                       :description ""
                                                                                                                       :majorVersion ""
                                                                                                                       :minorVersion ""
                                                                                                                       :status ""
                                                                                                                       :supportedComponentSources ""
                                                                                                                       :templateName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplateVersion"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.UpdateServiceTemplateVersion"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.UpdateServiceTemplateVersion");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"templateName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplateVersion"

	payload := strings.NewReader("{\n  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"templateName\": \"\"\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: 180

{
  "compatibleEnvironmentTemplates": "",
  "description": "",
  "majorVersion": "",
  "minorVersion": "",
  "status": "",
  "supportedComponentSources": "",
  "templateName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplateVersion")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"templateName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplateVersion"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"templateName\": \"\"\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  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"templateName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplateVersion")
  .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=AwsProton20200720.UpdateServiceTemplateVersion")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"templateName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  compatibleEnvironmentTemplates: '',
  description: '',
  majorVersion: '',
  minorVersion: '',
  status: '',
  supportedComponentSources: '',
  templateName: ''
});

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=AwsProton20200720.UpdateServiceTemplateVersion');
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=AwsProton20200720.UpdateServiceTemplateVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    compatibleEnvironmentTemplates: '',
    description: '',
    majorVersion: '',
    minorVersion: '',
    status: '',
    supportedComponentSources: '',
    templateName: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplateVersion';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"compatibleEnvironmentTemplates":"","description":"","majorVersion":"","minorVersion":"","status":"","supportedComponentSources":"","templateName":""}'
};

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=AwsProton20200720.UpdateServiceTemplateVersion',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "compatibleEnvironmentTemplates": "",\n  "description": "",\n  "majorVersion": "",\n  "minorVersion": "",\n  "status": "",\n  "supportedComponentSources": "",\n  "templateName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"templateName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplateVersion")
  .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({
  compatibleEnvironmentTemplates: '',
  description: '',
  majorVersion: '',
  minorVersion: '',
  status: '',
  supportedComponentSources: '',
  templateName: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplateVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    compatibleEnvironmentTemplates: '',
    description: '',
    majorVersion: '',
    minorVersion: '',
    status: '',
    supportedComponentSources: '',
    templateName: ''
  },
  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=AwsProton20200720.UpdateServiceTemplateVersion');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  compatibleEnvironmentTemplates: '',
  description: '',
  majorVersion: '',
  minorVersion: '',
  status: '',
  supportedComponentSources: '',
  templateName: ''
});

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=AwsProton20200720.UpdateServiceTemplateVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    compatibleEnvironmentTemplates: '',
    description: '',
    majorVersion: '',
    minorVersion: '',
    status: '',
    supportedComponentSources: '',
    templateName: ''
  }
};

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=AwsProton20200720.UpdateServiceTemplateVersion';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"compatibleEnvironmentTemplates":"","description":"","majorVersion":"","minorVersion":"","status":"","supportedComponentSources":"","templateName":""}'
};

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 = @{ @"compatibleEnvironmentTemplates": @"",
                              @"description": @"",
                              @"majorVersion": @"",
                              @"minorVersion": @"",
                              @"status": @"",
                              @"supportedComponentSources": @"",
                              @"templateName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplateVersion"]
                                                       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=AwsProton20200720.UpdateServiceTemplateVersion" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"templateName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplateVersion",
  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([
    'compatibleEnvironmentTemplates' => '',
    'description' => '',
    'majorVersion' => '',
    'minorVersion' => '',
    'status' => '',
    'supportedComponentSources' => '',
    'templateName' => ''
  ]),
  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=AwsProton20200720.UpdateServiceTemplateVersion', [
  'body' => '{
  "compatibleEnvironmentTemplates": "",
  "description": "",
  "majorVersion": "",
  "minorVersion": "",
  "status": "",
  "supportedComponentSources": "",
  "templateName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplateVersion');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'compatibleEnvironmentTemplates' => '',
  'description' => '',
  'majorVersion' => '',
  'minorVersion' => '',
  'status' => '',
  'supportedComponentSources' => '',
  'templateName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'compatibleEnvironmentTemplates' => '',
  'description' => '',
  'majorVersion' => '',
  'minorVersion' => '',
  'status' => '',
  'supportedComponentSources' => '',
  'templateName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplateVersion');
$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=AwsProton20200720.UpdateServiceTemplateVersion' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "compatibleEnvironmentTemplates": "",
  "description": "",
  "majorVersion": "",
  "minorVersion": "",
  "status": "",
  "supportedComponentSources": "",
  "templateName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplateVersion' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "compatibleEnvironmentTemplates": "",
  "description": "",
  "majorVersion": "",
  "minorVersion": "",
  "status": "",
  "supportedComponentSources": "",
  "templateName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.UpdateServiceTemplateVersion"

payload = {
    "compatibleEnvironmentTemplates": "",
    "description": "",
    "majorVersion": "",
    "minorVersion": "",
    "status": "",
    "supportedComponentSources": "",
    "templateName": ""
}
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=AwsProton20200720.UpdateServiceTemplateVersion"

payload <- "{\n  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.UpdateServiceTemplateVersion")

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  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"templateName\": \"\"\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  \"compatibleEnvironmentTemplates\": \"\",\n  \"description\": \"\",\n  \"majorVersion\": \"\",\n  \"minorVersion\": \"\",\n  \"status\": \"\",\n  \"supportedComponentSources\": \"\",\n  \"templateName\": \"\"\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=AwsProton20200720.UpdateServiceTemplateVersion";

    let payload = json!({
        "compatibleEnvironmentTemplates": "",
        "description": "",
        "majorVersion": "",
        "minorVersion": "",
        "status": "",
        "supportedComponentSources": "",
        "templateName": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplateVersion' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "compatibleEnvironmentTemplates": "",
  "description": "",
  "majorVersion": "",
  "minorVersion": "",
  "status": "",
  "supportedComponentSources": "",
  "templateName": ""
}'

echo '{
  "compatibleEnvironmentTemplates": "",
  "description": "",
  "majorVersion": "",
  "minorVersion": "",
  "status": "",
  "supportedComponentSources": "",
  "templateName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplateVersion' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "compatibleEnvironmentTemplates": "",\n  "description": "",\n  "majorVersion": "",\n  "minorVersion": "",\n  "status": "",\n  "supportedComponentSources": "",\n  "templateName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplateVersion'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "compatibleEnvironmentTemplates": "",
  "description": "",
  "majorVersion": "",
  "minorVersion": "",
  "status": "",
  "supportedComponentSources": "",
  "templateName": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateServiceTemplateVersion")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateTemplateSyncConfig

{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateTemplateSyncConfig

HEADERS

X-Amz-Target

BODY json

{
  "branch": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "subdirectory": "",
  "templateName": "",
  "templateType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateTemplateSyncConfig");

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  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"subdirectory\": \"\",\n  \"templateName\": \"\",\n  \"templateType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateTemplateSyncConfig" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:branch ""
                                                                                                                   :repositoryName ""
                                                                                                                   :repositoryProvider ""
                                                                                                                   :subdirectory ""
                                                                                                                   :templateName ""
                                                                                                                   :templateType ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateTemplateSyncConfig"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"subdirectory\": \"\",\n  \"templateName\": \"\",\n  \"templateType\": \"\"\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=AwsProton20200720.UpdateTemplateSyncConfig"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"subdirectory\": \"\",\n  \"templateName\": \"\",\n  \"templateType\": \"\"\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=AwsProton20200720.UpdateTemplateSyncConfig");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"subdirectory\": \"\",\n  \"templateName\": \"\",\n  \"templateType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateTemplateSyncConfig"

	payload := strings.NewReader("{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"subdirectory\": \"\",\n  \"templateName\": \"\",\n  \"templateType\": \"\"\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: 136

{
  "branch": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "subdirectory": "",
  "templateName": "",
  "templateType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateTemplateSyncConfig")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"subdirectory\": \"\",\n  \"templateName\": \"\",\n  \"templateType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateTemplateSyncConfig"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"subdirectory\": \"\",\n  \"templateName\": \"\",\n  \"templateType\": \"\"\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  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"subdirectory\": \"\",\n  \"templateName\": \"\",\n  \"templateType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateTemplateSyncConfig")
  .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=AwsProton20200720.UpdateTemplateSyncConfig")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"subdirectory\": \"\",\n  \"templateName\": \"\",\n  \"templateType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  branch: '',
  repositoryName: '',
  repositoryProvider: '',
  subdirectory: '',
  templateName: '',
  templateType: ''
});

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=AwsProton20200720.UpdateTemplateSyncConfig');
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=AwsProton20200720.UpdateTemplateSyncConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    branch: '',
    repositoryName: '',
    repositoryProvider: '',
    subdirectory: '',
    templateName: '',
    templateType: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateTemplateSyncConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"branch":"","repositoryName":"","repositoryProvider":"","subdirectory":"","templateName":"","templateType":""}'
};

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=AwsProton20200720.UpdateTemplateSyncConfig',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "branch": "",\n  "repositoryName": "",\n  "repositoryProvider": "",\n  "subdirectory": "",\n  "templateName": "",\n  "templateType": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"subdirectory\": \"\",\n  \"templateName\": \"\",\n  \"templateType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateTemplateSyncConfig")
  .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({
  branch: '',
  repositoryName: '',
  repositoryProvider: '',
  subdirectory: '',
  templateName: '',
  templateType: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateTemplateSyncConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    branch: '',
    repositoryName: '',
    repositoryProvider: '',
    subdirectory: '',
    templateName: '',
    templateType: ''
  },
  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=AwsProton20200720.UpdateTemplateSyncConfig');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  branch: '',
  repositoryName: '',
  repositoryProvider: '',
  subdirectory: '',
  templateName: '',
  templateType: ''
});

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=AwsProton20200720.UpdateTemplateSyncConfig',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    branch: '',
    repositoryName: '',
    repositoryProvider: '',
    subdirectory: '',
    templateName: '',
    templateType: ''
  }
};

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=AwsProton20200720.UpdateTemplateSyncConfig';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"branch":"","repositoryName":"","repositoryProvider":"","subdirectory":"","templateName":"","templateType":""}'
};

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 = @{ @"branch": @"",
                              @"repositoryName": @"",
                              @"repositoryProvider": @"",
                              @"subdirectory": @"",
                              @"templateName": @"",
                              @"templateType": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateTemplateSyncConfig"]
                                                       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=AwsProton20200720.UpdateTemplateSyncConfig" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"subdirectory\": \"\",\n  \"templateName\": \"\",\n  \"templateType\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateTemplateSyncConfig",
  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([
    'branch' => '',
    'repositoryName' => '',
    'repositoryProvider' => '',
    'subdirectory' => '',
    'templateName' => '',
    'templateType' => ''
  ]),
  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=AwsProton20200720.UpdateTemplateSyncConfig', [
  'body' => '{
  "branch": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "subdirectory": "",
  "templateName": "",
  "templateType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateTemplateSyncConfig');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'branch' => '',
  'repositoryName' => '',
  'repositoryProvider' => '',
  'subdirectory' => '',
  'templateName' => '',
  'templateType' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'branch' => '',
  'repositoryName' => '',
  'repositoryProvider' => '',
  'subdirectory' => '',
  'templateName' => '',
  'templateType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateTemplateSyncConfig');
$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=AwsProton20200720.UpdateTemplateSyncConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "branch": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "subdirectory": "",
  "templateName": "",
  "templateType": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateTemplateSyncConfig' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "branch": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "subdirectory": "",
  "templateName": "",
  "templateType": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"subdirectory\": \"\",\n  \"templateName\": \"\",\n  \"templateType\": \"\"\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=AwsProton20200720.UpdateTemplateSyncConfig"

payload = {
    "branch": "",
    "repositoryName": "",
    "repositoryProvider": "",
    "subdirectory": "",
    "templateName": "",
    "templateType": ""
}
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=AwsProton20200720.UpdateTemplateSyncConfig"

payload <- "{\n  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"subdirectory\": \"\",\n  \"templateName\": \"\",\n  \"templateType\": \"\"\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=AwsProton20200720.UpdateTemplateSyncConfig")

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  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"subdirectory\": \"\",\n  \"templateName\": \"\",\n  \"templateType\": \"\"\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  \"branch\": \"\",\n  \"repositoryName\": \"\",\n  \"repositoryProvider\": \"\",\n  \"subdirectory\": \"\",\n  \"templateName\": \"\",\n  \"templateType\": \"\"\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=AwsProton20200720.UpdateTemplateSyncConfig";

    let payload = json!({
        "branch": "",
        "repositoryName": "",
        "repositoryProvider": "",
        "subdirectory": "",
        "templateName": "",
        "templateType": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateTemplateSyncConfig' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "branch": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "subdirectory": "",
  "templateName": "",
  "templateType": ""
}'

echo '{
  "branch": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "subdirectory": "",
  "templateName": "",
  "templateType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateTemplateSyncConfig' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "branch": "",\n  "repositoryName": "",\n  "repositoryProvider": "",\n  "subdirectory": "",\n  "templateName": "",\n  "templateType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateTemplateSyncConfig'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "branch": "",
  "repositoryName": "",
  "repositoryProvider": "",
  "subdirectory": "",
  "templateName": "",
  "templateType": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AwsProton20200720.UpdateTemplateSyncConfig")! 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()