Amazon Simple Workflow Service

POST CountClosedWorkflowExecutions

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions

HEADERS

X-Amz-Target

BODY json

{
  "domain": "",
  "startTimeFilter": "",
  "closeTimeFilter": "",
  "executionFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "closeStatusFilter": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"closeStatusFilter\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions" {:headers {:x-amz-target ""}
                                                                                                              :content-type :json
                                                                                                              :form-params {:domain ""
                                                                                                                            :startTimeFilter ""
                                                                                                                            :closeTimeFilter ""
                                                                                                                            :executionFilter ""
                                                                                                                            :typeFilter ""
                                                                                                                            :tagFilter ""
                                                                                                                            :closeStatusFilter ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"closeStatusFilter\": \"\"\n}"

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

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

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"closeStatusFilter\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions"

	payload := strings.NewReader("{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"closeStatusFilter\": \"\"\n}")

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

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

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

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

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

}

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

{
  "domain": "",
  "startTimeFilter": "",
  "closeTimeFilter": "",
  "executionFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "closeStatusFilter": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"closeStatusFilter\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"closeStatusFilter\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"closeStatusFilter\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"closeStatusFilter\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  domain: '',
  startTimeFilter: '',
  closeTimeFilter: '',
  executionFilter: '',
  typeFilter: '',
  tagFilter: '',
  closeStatusFilter: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    domain: '',
    startTimeFilter: '',
    closeTimeFilter: '',
    executionFilter: '',
    typeFilter: '',
    tagFilter: '',
    closeStatusFilter: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","startTimeFilter":"","closeTimeFilter":"","executionFilter":"","typeFilter":"","tagFilter":"","closeStatusFilter":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "domain": "",\n  "startTimeFilter": "",\n  "closeTimeFilter": "",\n  "executionFilter": "",\n  "typeFilter": "",\n  "tagFilter": "",\n  "closeStatusFilter": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"closeStatusFilter\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  domain: '',
  startTimeFilter: '',
  closeTimeFilter: '',
  executionFilter: '',
  typeFilter: '',
  tagFilter: '',
  closeStatusFilter: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    domain: '',
    startTimeFilter: '',
    closeTimeFilter: '',
    executionFilter: '',
    typeFilter: '',
    tagFilter: '',
    closeStatusFilter: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  domain: '',
  startTimeFilter: '',
  closeTimeFilter: '',
  executionFilter: '',
  typeFilter: '',
  tagFilter: '',
  closeStatusFilter: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    domain: '',
    startTimeFilter: '',
    closeTimeFilter: '',
    executionFilter: '',
    typeFilter: '',
    tagFilter: '',
    closeStatusFilter: ''
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","startTimeFilter":"","closeTimeFilter":"","executionFilter":"","typeFilter":"","tagFilter":"","closeStatusFilter":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"domain": @"",
                              @"startTimeFilter": @"",
                              @"closeTimeFilter": @"",
                              @"executionFilter": @"",
                              @"typeFilter": @"",
                              @"tagFilter": @"",
                              @"closeStatusFilter": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"closeStatusFilter\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'domain' => '',
    'startTimeFilter' => '',
    'closeTimeFilter' => '',
    'executionFilter' => '',
    'typeFilter' => '',
    'tagFilter' => '',
    'closeStatusFilter' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions', [
  'body' => '{
  "domain": "",
  "startTimeFilter": "",
  "closeTimeFilter": "",
  "executionFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "closeStatusFilter": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'domain' => '',
  'startTimeFilter' => '',
  'closeTimeFilter' => '',
  'executionFilter' => '',
  'typeFilter' => '',
  'tagFilter' => '',
  'closeStatusFilter' => ''
]));

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

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

append(json_encode([
  'domain' => '',
  'startTimeFilter' => '',
  'closeTimeFilter' => '',
  'executionFilter' => '',
  'typeFilter' => '',
  'tagFilter' => '',
  'closeStatusFilter' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "startTimeFilter": "",
  "closeTimeFilter": "",
  "executionFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "closeStatusFilter": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "startTimeFilter": "",
  "closeTimeFilter": "",
  "executionFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "closeStatusFilter": ""
}'

import http.client

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

payload = "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"closeStatusFilter\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions"

payload = {
    "domain": "",
    "startTimeFilter": "",
    "closeTimeFilter": "",
    "executionFilter": "",
    "typeFilter": "",
    "tagFilter": "",
    "closeStatusFilter": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions"

payload <- "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"closeStatusFilter\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"closeStatusFilter\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"closeStatusFilter\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "domain": "",
        "startTimeFilter": "",
        "closeTimeFilter": "",
        "executionFilter": "",
        "typeFilter": "",
        "tagFilter": "",
        "closeStatusFilter": ""
    });

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

    let 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=SimpleWorkflowService.CountClosedWorkflowExecutions' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "domain": "",
  "startTimeFilter": "",
  "closeTimeFilter": "",
  "executionFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "closeStatusFilter": ""
}'

echo '{
  "domain": "",
  "startTimeFilter": "",
  "closeTimeFilter": "",
  "executionFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "closeStatusFilter": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "domain": "",\n  "startTimeFilter": "",\n  "closeTimeFilter": "",\n  "executionFilter": "",\n  "typeFilter": "",\n  "tagFilter": "",\n  "closeStatusFilter": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountClosedWorkflowExecutions'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "domain": "",
  "startTimeFilter": "",
  "closeTimeFilter": "",
  "executionFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "closeStatusFilter": ""
] as [String : Any]

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

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 CountOpenWorkflowExecutions

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountOpenWorkflowExecutions

HEADERS

X-Amz-Target

BODY json

{
  "domain": "",
  "startTimeFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "executionFilter": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"executionFilter\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountOpenWorkflowExecutions" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:domain ""
                                                                                                                          :startTimeFilter ""
                                                                                                                          :typeFilter ""
                                                                                                                          :tagFilter ""
                                                                                                                          :executionFilter ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountOpenWorkflowExecutions"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"executionFilter\": \"\"\n}"

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

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

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountOpenWorkflowExecutions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"executionFilter\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountOpenWorkflowExecutions"

	payload := strings.NewReader("{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"executionFilter\": \"\"\n}")

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

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

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

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

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

}

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

{
  "domain": "",
  "startTimeFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "executionFilter": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"executionFilter\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountOpenWorkflowExecutions")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountOpenWorkflowExecutions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"executionFilter\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  domain: '',
  startTimeFilter: '',
  typeFilter: '',
  tagFilter: '',
  executionFilter: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountOpenWorkflowExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    domain: '',
    startTimeFilter: '',
    typeFilter: '',
    tagFilter: '',
    executionFilter: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountOpenWorkflowExecutions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","startTimeFilter":"","typeFilter":"","tagFilter":"","executionFilter":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountOpenWorkflowExecutions',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "domain": "",\n  "startTimeFilter": "",\n  "typeFilter": "",\n  "tagFilter": "",\n  "executionFilter": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"executionFilter\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountOpenWorkflowExecutions")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  domain: '',
  startTimeFilter: '',
  typeFilter: '',
  tagFilter: '',
  executionFilter: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountOpenWorkflowExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    domain: '',
    startTimeFilter: '',
    typeFilter: '',
    tagFilter: '',
    executionFilter: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  domain: '',
  startTimeFilter: '',
  typeFilter: '',
  tagFilter: '',
  executionFilter: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountOpenWorkflowExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    domain: '',
    startTimeFilter: '',
    typeFilter: '',
    tagFilter: '',
    executionFilter: ''
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountOpenWorkflowExecutions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","startTimeFilter":"","typeFilter":"","tagFilter":"","executionFilter":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"domain": @"",
                              @"startTimeFilter": @"",
                              @"typeFilter": @"",
                              @"tagFilter": @"",
                              @"executionFilter": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountOpenWorkflowExecutions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountOpenWorkflowExecutions" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"executionFilter\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountOpenWorkflowExecutions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'domain' => '',
    'startTimeFilter' => '',
    'typeFilter' => '',
    'tagFilter' => '',
    'executionFilter' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountOpenWorkflowExecutions', [
  'body' => '{
  "domain": "",
  "startTimeFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "executionFilter": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'domain' => '',
  'startTimeFilter' => '',
  'typeFilter' => '',
  'tagFilter' => '',
  'executionFilter' => ''
]));

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

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

append(json_encode([
  'domain' => '',
  'startTimeFilter' => '',
  'typeFilter' => '',
  'tagFilter' => '',
  'executionFilter' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountOpenWorkflowExecutions');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountOpenWorkflowExecutions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "startTimeFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "executionFilter": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountOpenWorkflowExecutions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "startTimeFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "executionFilter": ""
}'

import http.client

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

payload = "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"executionFilter\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountOpenWorkflowExecutions"

payload = {
    "domain": "",
    "startTimeFilter": "",
    "typeFilter": "",
    "tagFilter": "",
    "executionFilter": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountOpenWorkflowExecutions"

payload <- "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"executionFilter\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "domain": "",
        "startTimeFilter": "",
        "typeFilter": "",
        "tagFilter": "",
        "executionFilter": ""
    });

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

    let 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=SimpleWorkflowService.CountOpenWorkflowExecutions' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "domain": "",
  "startTimeFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "executionFilter": ""
}'

echo '{
  "domain": "",
  "startTimeFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "executionFilter": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountOpenWorkflowExecutions' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "domain": "",\n  "startTimeFilter": "",\n  "typeFilter": "",\n  "tagFilter": "",\n  "executionFilter": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountOpenWorkflowExecutions'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "domain": "",
  "startTimeFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "executionFilter": ""
] as [String : Any]

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

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 CountPendingActivityTasks

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingActivityTasks

HEADERS

X-Amz-Target

BODY json

{
  "domain": "",
  "taskList": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"domain\": \"\",\n  \"taskList\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingActivityTasks" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:domain ""
                                                                                                                        :taskList ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingActivityTasks"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"domain\": \"\",\n  \"taskList\": \"\"\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingActivityTasks"

	payload := strings.NewReader("{\n  \"domain\": \"\",\n  \"taskList\": \"\"\n}")

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

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

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

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

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

}

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

{
  "domain": "",
  "taskList": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

const data = JSON.stringify({
  domain: '',
  taskList: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingActivityTasks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {domain: '', taskList: ''}
};

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

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

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

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

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"taskList\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingActivityTasks")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({domain: '', taskList: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingActivityTasks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {domain: '', taskList: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  domain: '',
  taskList: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingActivityTasks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {domain: '', taskList: ''}
};

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

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

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

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

#import 

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingActivityTasks"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingActivityTasks" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"domain\": \"\",\n  \"taskList\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingActivityTasks",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'domain' => '',
    'taskList' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

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

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'domain' => '',
  'taskList' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingActivityTasks');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

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

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

import http.client

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

payload = "{\n  \"domain\": \"\",\n  \"taskList\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingActivityTasks"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingActivityTasks"

payload <- "{\n  \"domain\": \"\",\n  \"taskList\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "domain": "",
        "taskList": ""
    });

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

    let 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=SimpleWorkflowService.CountPendingActivityTasks' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "domain": "",
  "taskList": ""
}'

echo '{
  "domain": "",
  "taskList": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingActivityTasks' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 CountPendingDecisionTasks

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingDecisionTasks

HEADERS

X-Amz-Target

BODY json

{
  "domain": "",
  "taskList": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"domain\": \"\",\n  \"taskList\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingDecisionTasks" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:domain ""
                                                                                                                        :taskList ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingDecisionTasks"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"domain\": \"\",\n  \"taskList\": \"\"\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingDecisionTasks"

	payload := strings.NewReader("{\n  \"domain\": \"\",\n  \"taskList\": \"\"\n}")

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

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

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

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

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

}

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

{
  "domain": "",
  "taskList": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

const data = JSON.stringify({
  domain: '',
  taskList: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingDecisionTasks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {domain: '', taskList: ''}
};

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

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

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

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

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"taskList\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingDecisionTasks")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({domain: '', taskList: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingDecisionTasks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {domain: '', taskList: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  domain: '',
  taskList: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingDecisionTasks',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {domain: '', taskList: ''}
};

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

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

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

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

#import 

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingDecisionTasks"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingDecisionTasks" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"domain\": \"\",\n  \"taskList\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingDecisionTasks",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'domain' => '',
    'taskList' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

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

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'domain' => '',
  'taskList' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingDecisionTasks');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

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

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

import http.client

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

payload = "{\n  \"domain\": \"\",\n  \"taskList\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingDecisionTasks"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingDecisionTasks"

payload <- "{\n  \"domain\": \"\",\n  \"taskList\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "domain": "",
        "taskList": ""
    });

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

    let 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=SimpleWorkflowService.CountPendingDecisionTasks' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "domain": "",
  "taskList": ""
}'

echo '{
  "domain": "",
  "taskList": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.CountPendingDecisionTasks' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 DeprecateActivityType

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateActivityType

HEADERS

X-Amz-Target

BODY json

{
  "domain": "",
  "activityType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateActivityType" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:domain ""
                                                                                                                    :activityType ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateActivityType"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateActivityType"

	payload := strings.NewReader("{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}")

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

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

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

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

	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

{
  "domain": "",
  "activityType": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

const data = JSON.stringify({
  domain: '',
  activityType: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateActivityType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {domain: '', activityType: ''}
};

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

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

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

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

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateActivityType")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({domain: '', activityType: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateActivityType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {domain: '', activityType: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  domain: '',
  activityType: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateActivityType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {domain: '', activityType: ''}
};

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

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

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

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

#import 

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateActivityType"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateActivityType" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateActivityType",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'domain' => '',
    'activityType' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

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

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'domain' => '',
  'activityType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateActivityType');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

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

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

import http.client

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

payload = "{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateActivityType"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateActivityType"

payload <- "{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "domain": "",
        "activityType": ""
    });

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

    let 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=SimpleWorkflowService.DeprecateActivityType' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "domain": "",
  "activityType": ""
}'

echo '{
  "domain": "",
  "activityType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateActivityType' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 DeprecateDomain

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateDomain

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=SimpleWorkflowService.DeprecateDomain");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-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=SimpleWorkflowService.DeprecateDomain" {:headers {:x-amz-target ""}
                                                                                                :content-type :json
                                                                                                :form-params {:name ""}})

require "http/client"

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

	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=SimpleWorkflowService.DeprecateDomain")
  .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=SimpleWorkflowService.DeprecateDomain"))
    .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=SimpleWorkflowService.DeprecateDomain")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateDomain")
  .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=SimpleWorkflowService.DeprecateDomain');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateDomain',
  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=SimpleWorkflowService.DeprecateDomain';
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=SimpleWorkflowService.DeprecateDomain',
  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=SimpleWorkflowService.DeprecateDomain")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

  res.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=SimpleWorkflowService.DeprecateDomain',
  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=SimpleWorkflowService.DeprecateDomain');

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=SimpleWorkflowService.DeprecateDomain',
  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=SimpleWorkflowService.DeprecateDomain';
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=SimpleWorkflowService.DeprecateDomain"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateDomain" 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=SimpleWorkflowService.DeprecateDomain",
  CURLOPT_RETURNTRANSFER => 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=SimpleWorkflowService.DeprecateDomain', [
  'body' => '{
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateDomain');
$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=SimpleWorkflowService.DeprecateDomain');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateDomain' -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=SimpleWorkflowService.DeprecateDomain' -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=SimpleWorkflowService.DeprecateDomain"

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=SimpleWorkflowService.DeprecateDomain"

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=SimpleWorkflowService.DeprecateDomain")

http = Net::HTTP.new(url.host, 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=SimpleWorkflowService.DeprecateDomain";

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

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

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 DeprecateWorkflowType

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateWorkflowType

HEADERS

X-Amz-Target

BODY json

{
  "domain": "",
  "workflowType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateWorkflowType" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:domain ""
                                                                                                                    :workflowType ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateWorkflowType"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateWorkflowType"

	payload := strings.NewReader("{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}")

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

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

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

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

	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

{
  "domain": "",
  "workflowType": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

const data = JSON.stringify({
  domain: '',
  workflowType: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateWorkflowType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {domain: '', workflowType: ''}
};

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

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

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

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

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateWorkflowType")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({domain: '', workflowType: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateWorkflowType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {domain: '', workflowType: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  domain: '',
  workflowType: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateWorkflowType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {domain: '', workflowType: ''}
};

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

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

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

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

#import 

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateWorkflowType"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateWorkflowType" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateWorkflowType",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'domain' => '',
    'workflowType' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

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

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'domain' => '',
  'workflowType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateWorkflowType');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

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

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

import http.client

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

payload = "{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateWorkflowType"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateWorkflowType"

payload <- "{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "domain": "",
        "workflowType": ""
    });

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

    let 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=SimpleWorkflowService.DeprecateWorkflowType' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "domain": "",
  "workflowType": ""
}'

echo '{
  "domain": "",
  "workflowType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DeprecateWorkflowType' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 DescribeActivityType

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeActivityType

HEADERS

X-Amz-Target

BODY json

{
  "domain": "",
  "activityType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeActivityType" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:domain ""
                                                                                                                   :activityType ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeActivityType"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeActivityType"

	payload := strings.NewReader("{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}")

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

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

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

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

	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

{
  "domain": "",
  "activityType": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

const data = JSON.stringify({
  domain: '',
  activityType: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeActivityType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {domain: '', activityType: ''}
};

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

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

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

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

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeActivityType")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({domain: '', activityType: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeActivityType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {domain: '', activityType: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  domain: '',
  activityType: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeActivityType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {domain: '', activityType: ''}
};

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

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

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

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

#import 

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeActivityType"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeActivityType" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeActivityType",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'domain' => '',
    'activityType' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

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

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'domain' => '',
  'activityType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeActivityType');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

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

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

import http.client

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

payload = "{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeActivityType"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeActivityType"

payload <- "{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "domain": "",
        "activityType": ""
    });

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

    let 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=SimpleWorkflowService.DescribeActivityType' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "domain": "",
  "activityType": ""
}'

echo '{
  "domain": "",
  "activityType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeActivityType' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 DescribeDomain

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeDomain

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=SimpleWorkflowService.DescribeDomain");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-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=SimpleWorkflowService.DescribeDomain" {:headers {:x-amz-target ""}
                                                                                               :content-type :json
                                                                                               :form-params {:name ""}})

require "http/client"

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

	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=SimpleWorkflowService.DescribeDomain")
  .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=SimpleWorkflowService.DescribeDomain"))
    .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=SimpleWorkflowService.DescribeDomain")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeDomain")
  .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=SimpleWorkflowService.DescribeDomain');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeDomain',
  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=SimpleWorkflowService.DescribeDomain';
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=SimpleWorkflowService.DescribeDomain',
  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=SimpleWorkflowService.DescribeDomain")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

  res.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=SimpleWorkflowService.DescribeDomain',
  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=SimpleWorkflowService.DescribeDomain');

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=SimpleWorkflowService.DescribeDomain',
  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=SimpleWorkflowService.DescribeDomain';
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=SimpleWorkflowService.DescribeDomain"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeDomain" 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=SimpleWorkflowService.DescribeDomain",
  CURLOPT_RETURNTRANSFER => 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=SimpleWorkflowService.DescribeDomain', [
  'body' => '{
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeDomain');
$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=SimpleWorkflowService.DescribeDomain');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeDomain' -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=SimpleWorkflowService.DescribeDomain' -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=SimpleWorkflowService.DescribeDomain"

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=SimpleWorkflowService.DescribeDomain"

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=SimpleWorkflowService.DescribeDomain")

http = Net::HTTP.new(url.host, 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=SimpleWorkflowService.DescribeDomain";

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

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

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 DescribeWorkflowExecution

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowExecution

HEADERS

X-Amz-Target

BODY json

{
  "domain": "",
  "execution": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"domain\": \"\",\n  \"execution\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowExecution" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:domain ""
                                                                                                                        :execution ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowExecution"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"domain\": \"\",\n  \"execution\": \"\"\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowExecution"

	payload := strings.NewReader("{\n  \"domain\": \"\",\n  \"execution\": \"\"\n}")

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

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

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

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

	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

{
  "domain": "",
  "execution": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

const data = JSON.stringify({
  domain: '',
  execution: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowExecution',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {domain: '', execution: ''}
};

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

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

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

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

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"execution\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowExecution")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({domain: '', execution: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowExecution',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {domain: '', execution: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  domain: '',
  execution: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowExecution',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {domain: '', execution: ''}
};

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

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

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

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

#import 

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowExecution"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowExecution" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"domain\": \"\",\n  \"execution\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowExecution",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'domain' => '',
    'execution' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

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

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'domain' => '',
  'execution' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowExecution');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

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

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

import http.client

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

payload = "{\n  \"domain\": \"\",\n  \"execution\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowExecution"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowExecution"

payload <- "{\n  \"domain\": \"\",\n  \"execution\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "domain": "",
        "execution": ""
    });

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

    let 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=SimpleWorkflowService.DescribeWorkflowExecution' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "domain": "",
  "execution": ""
}'

echo '{
  "domain": "",
  "execution": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowExecution' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 DescribeWorkflowType

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowType

HEADERS

X-Amz-Target

BODY json

{
  "domain": "",
  "workflowType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowType" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:domain ""
                                                                                                                   :workflowType ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowType"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowType"

	payload := strings.NewReader("{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}")

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

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

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

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

	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

{
  "domain": "",
  "workflowType": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

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

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

const data = JSON.stringify({
  domain: '',
  workflowType: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {domain: '', workflowType: ''}
};

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

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

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

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

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowType")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({domain: '', workflowType: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {domain: '', workflowType: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  domain: '',
  workflowType: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {domain: '', workflowType: ''}
};

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

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

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

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

#import 

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowType"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowType" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowType",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'domain' => '',
    'workflowType' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

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

echo $response->getBody();

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

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

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

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

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

append(json_encode([
  'domain' => '',
  'workflowType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowType');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

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

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

import http.client

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

payload = "{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowType"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowType"

payload <- "{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "domain": "",
        "workflowType": ""
    });

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

    let 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=SimpleWorkflowService.DescribeWorkflowType' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "domain": "",
  "workflowType": ""
}'

echo '{
  "domain": "",
  "workflowType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.DescribeWorkflowType' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 GetWorkflowExecutionHistory

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.GetWorkflowExecutionHistory

HEADERS

X-Amz-Target

BODY json

{
  "domain": "",
  "execution": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"domain\": \"\",\n  \"execution\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.GetWorkflowExecutionHistory" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:domain ""
                                                                                                                          :execution ""
                                                                                                                          :nextPageToken ""
                                                                                                                          :maximumPageSize ""
                                                                                                                          :reverseOrder ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.GetWorkflowExecutionHistory"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"domain\": \"\",\n  \"execution\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"

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

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

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.GetWorkflowExecutionHistory");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"domain\": \"\",\n  \"execution\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.GetWorkflowExecutionHistory"

	payload := strings.NewReader("{\n  \"domain\": \"\",\n  \"execution\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")

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

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

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

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

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

}

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

{
  "domain": "",
  "execution": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"execution\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.GetWorkflowExecutionHistory")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.GetWorkflowExecutionHistory")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"domain\": \"\",\n  \"execution\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  domain: '',
  execution: '',
  nextPageToken: '',
  maximumPageSize: '',
  reverseOrder: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.GetWorkflowExecutionHistory',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    domain: '',
    execution: '',
    nextPageToken: '',
    maximumPageSize: '',
    reverseOrder: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.GetWorkflowExecutionHistory';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","execution":"","nextPageToken":"","maximumPageSize":"","reverseOrder":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.GetWorkflowExecutionHistory',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "domain": "",\n  "execution": "",\n  "nextPageToken": "",\n  "maximumPageSize": "",\n  "reverseOrder": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"execution\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.GetWorkflowExecutionHistory")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  domain: '',
  execution: '',
  nextPageToken: '',
  maximumPageSize: '',
  reverseOrder: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.GetWorkflowExecutionHistory',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    domain: '',
    execution: '',
    nextPageToken: '',
    maximumPageSize: '',
    reverseOrder: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  domain: '',
  execution: '',
  nextPageToken: '',
  maximumPageSize: '',
  reverseOrder: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.GetWorkflowExecutionHistory',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    domain: '',
    execution: '',
    nextPageToken: '',
    maximumPageSize: '',
    reverseOrder: ''
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.GetWorkflowExecutionHistory';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","execution":"","nextPageToken":"","maximumPageSize":"","reverseOrder":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"domain": @"",
                              @"execution": @"",
                              @"nextPageToken": @"",
                              @"maximumPageSize": @"",
                              @"reverseOrder": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.GetWorkflowExecutionHistory"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.GetWorkflowExecutionHistory" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"domain\": \"\",\n  \"execution\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.GetWorkflowExecutionHistory",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'domain' => '',
    'execution' => '',
    'nextPageToken' => '',
    'maximumPageSize' => '',
    'reverseOrder' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.GetWorkflowExecutionHistory', [
  'body' => '{
  "domain": "",
  "execution": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'domain' => '',
  'execution' => '',
  'nextPageToken' => '',
  'maximumPageSize' => '',
  'reverseOrder' => ''
]));

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

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

append(json_encode([
  'domain' => '',
  'execution' => '',
  'nextPageToken' => '',
  'maximumPageSize' => '',
  'reverseOrder' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.GetWorkflowExecutionHistory');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.GetWorkflowExecutionHistory' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "execution": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.GetWorkflowExecutionHistory' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "execution": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}'

import http.client

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

payload = "{\n  \"domain\": \"\",\n  \"execution\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.GetWorkflowExecutionHistory"

payload = {
    "domain": "",
    "execution": "",
    "nextPageToken": "",
    "maximumPageSize": "",
    "reverseOrder": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.GetWorkflowExecutionHistory"

payload <- "{\n  \"domain\": \"\",\n  \"execution\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

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

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "domain": "",
        "execution": "",
        "nextPageToken": "",
        "maximumPageSize": "",
        "reverseOrder": ""
    });

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

    let 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=SimpleWorkflowService.GetWorkflowExecutionHistory' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "domain": "",
  "execution": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}'

echo '{
  "domain": "",
  "execution": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.GetWorkflowExecutionHistory' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "domain": "",\n  "execution": "",\n  "nextPageToken": "",\n  "maximumPageSize": "",\n  "reverseOrder": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.GetWorkflowExecutionHistory'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "domain": "",
  "execution": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
] as [String : Any]

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

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 ListActivityTypes

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListActivityTypes

HEADERS

X-Amz-Target

BODY json

{
  "domain": "",
  "name": "",
  "registrationStatus": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListActivityTypes" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:domain ""
                                                                                                                :name ""
                                                                                                                :registrationStatus ""
                                                                                                                :nextPageToken ""
                                                                                                                :maximumPageSize ""
                                                                                                                :reverseOrder ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListActivityTypes"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"

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

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

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListActivityTypes");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListActivityTypes"

	payload := strings.NewReader("{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")

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

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

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

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

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

}

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

{
  "domain": "",
  "name": "",
  "registrationStatus": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListActivityTypes")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListActivityTypes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListActivityTypes")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  domain: '',
  name: '',
  registrationStatus: '',
  nextPageToken: '',
  maximumPageSize: '',
  reverseOrder: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListActivityTypes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    domain: '',
    name: '',
    registrationStatus: '',
    nextPageToken: '',
    maximumPageSize: '',
    reverseOrder: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListActivityTypes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","name":"","registrationStatus":"","nextPageToken":"","maximumPageSize":"","reverseOrder":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListActivityTypes',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "domain": "",\n  "name": "",\n  "registrationStatus": "",\n  "nextPageToken": "",\n  "maximumPageSize": "",\n  "reverseOrder": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListActivityTypes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  domain: '',
  name: '',
  registrationStatus: '',
  nextPageToken: '',
  maximumPageSize: '',
  reverseOrder: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListActivityTypes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    domain: '',
    name: '',
    registrationStatus: '',
    nextPageToken: '',
    maximumPageSize: '',
    reverseOrder: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  domain: '',
  name: '',
  registrationStatus: '',
  nextPageToken: '',
  maximumPageSize: '',
  reverseOrder: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListActivityTypes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    domain: '',
    name: '',
    registrationStatus: '',
    nextPageToken: '',
    maximumPageSize: '',
    reverseOrder: ''
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListActivityTypes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","name":"","registrationStatus":"","nextPageToken":"","maximumPageSize":"","reverseOrder":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"domain": @"",
                              @"name": @"",
                              @"registrationStatus": @"",
                              @"nextPageToken": @"",
                              @"maximumPageSize": @"",
                              @"reverseOrder": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListActivityTypes"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListActivityTypes" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListActivityTypes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'domain' => '',
    'name' => '',
    'registrationStatus' => '',
    'nextPageToken' => '',
    'maximumPageSize' => '',
    'reverseOrder' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListActivityTypes', [
  'body' => '{
  "domain": "",
  "name": "",
  "registrationStatus": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'domain' => '',
  'name' => '',
  'registrationStatus' => '',
  'nextPageToken' => '',
  'maximumPageSize' => '',
  'reverseOrder' => ''
]));

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

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

append(json_encode([
  'domain' => '',
  'name' => '',
  'registrationStatus' => '',
  'nextPageToken' => '',
  'maximumPageSize' => '',
  'reverseOrder' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListActivityTypes');
$request->setRequestMethod('POST');
$request->setBody($body);

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

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

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListActivityTypes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "name": "",
  "registrationStatus": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListActivityTypes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "name": "",
  "registrationStatus": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}'

import http.client

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

payload = "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListActivityTypes"

payload = {
    "domain": "",
    "name": "",
    "registrationStatus": "",
    "nextPageToken": "",
    "maximumPageSize": "",
    "reverseOrder": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListActivityTypes"

payload <- "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "domain": "",
        "name": "",
        "registrationStatus": "",
        "nextPageToken": "",
        "maximumPageSize": "",
        "reverseOrder": ""
    });

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

    let 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=SimpleWorkflowService.ListActivityTypes' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "domain": "",
  "name": "",
  "registrationStatus": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}'

echo '{
  "domain": "",
  "name": "",
  "registrationStatus": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListActivityTypes' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "domain": "",\n  "name": "",\n  "registrationStatus": "",\n  "nextPageToken": "",\n  "maximumPageSize": "",\n  "reverseOrder": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListActivityTypes'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "domain": "",
  "name": "",
  "registrationStatus": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
] as [String : Any]

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

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

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 ListClosedWorkflowExecutions

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions

HEADERS

X-Amz-Target

BODY json

{
  "domain": "",
  "startTimeFilter": "",
  "closeTimeFilter": "",
  "executionFilter": "",
  "closeStatusFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"closeStatusFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:domain ""
                                                                                                                           :startTimeFilter ""
                                                                                                                           :closeTimeFilter ""
                                                                                                                           :executionFilter ""
                                                                                                                           :closeStatusFilter ""
                                                                                                                           :typeFilter ""
                                                                                                                           :tagFilter ""
                                                                                                                           :nextPageToken ""
                                                                                                                           :maximumPageSize ""
                                                                                                                           :reverseOrder ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"closeStatusFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"

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

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"closeStatusFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"closeStatusFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions"

	payload := strings.NewReader("{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"closeStatusFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")

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

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

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

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

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

}

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

{
  "domain": "",
  "startTimeFilter": "",
  "closeTimeFilter": "",
  "executionFilter": "",
  "closeStatusFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"closeStatusFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"closeStatusFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"closeStatusFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

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

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"closeStatusFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  domain: '',
  startTimeFilter: '',
  closeTimeFilter: '',
  executionFilter: '',
  closeStatusFilter: '',
  typeFilter: '',
  tagFilter: '',
  nextPageToken: '',
  maximumPageSize: '',
  reverseOrder: ''
});

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

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

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

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    domain: '',
    startTimeFilter: '',
    closeTimeFilter: '',
    executionFilter: '',
    closeStatusFilter: '',
    typeFilter: '',
    tagFilter: '',
    nextPageToken: '',
    maximumPageSize: '',
    reverseOrder: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","startTimeFilter":"","closeTimeFilter":"","executionFilter":"","closeStatusFilter":"","typeFilter":"","tagFilter":"","nextPageToken":"","maximumPageSize":"","reverseOrder":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "domain": "",\n  "startTimeFilter": "",\n  "closeTimeFilter": "",\n  "executionFilter": "",\n  "closeStatusFilter": "",\n  "typeFilter": "",\n  "tagFilter": "",\n  "nextPageToken": "",\n  "maximumPageSize": "",\n  "reverseOrder": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"closeStatusFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  domain: '',
  startTimeFilter: '',
  closeTimeFilter: '',
  executionFilter: '',
  closeStatusFilter: '',
  typeFilter: '',
  tagFilter: '',
  nextPageToken: '',
  maximumPageSize: '',
  reverseOrder: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    domain: '',
    startTimeFilter: '',
    closeTimeFilter: '',
    executionFilter: '',
    closeStatusFilter: '',
    typeFilter: '',
    tagFilter: '',
    nextPageToken: '',
    maximumPageSize: '',
    reverseOrder: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  domain: '',
  startTimeFilter: '',
  closeTimeFilter: '',
  executionFilter: '',
  closeStatusFilter: '',
  typeFilter: '',
  tagFilter: '',
  nextPageToken: '',
  maximumPageSize: '',
  reverseOrder: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    domain: '',
    startTimeFilter: '',
    closeTimeFilter: '',
    executionFilter: '',
    closeStatusFilter: '',
    typeFilter: '',
    tagFilter: '',
    nextPageToken: '',
    maximumPageSize: '',
    reverseOrder: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","startTimeFilter":"","closeTimeFilter":"","executionFilter":"","closeStatusFilter":"","typeFilter":"","tagFilter":"","nextPageToken":"","maximumPageSize":"","reverseOrder":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"domain": @"",
                              @"startTimeFilter": @"",
                              @"closeTimeFilter": @"",
                              @"executionFilter": @"",
                              @"closeStatusFilter": @"",
                              @"typeFilter": @"",
                              @"tagFilter": @"",
                              @"nextPageToken": @"",
                              @"maximumPageSize": @"",
                              @"reverseOrder": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"closeStatusFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'domain' => '',
    'startTimeFilter' => '',
    'closeTimeFilter' => '',
    'executionFilter' => '',
    'closeStatusFilter' => '',
    'typeFilter' => '',
    'tagFilter' => '',
    'nextPageToken' => '',
    'maximumPageSize' => '',
    'reverseOrder' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions', [
  'body' => '{
  "domain": "",
  "startTimeFilter": "",
  "closeTimeFilter": "",
  "executionFilter": "",
  "closeStatusFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'domain' => '',
  'startTimeFilter' => '',
  'closeTimeFilter' => '',
  'executionFilter' => '',
  'closeStatusFilter' => '',
  'typeFilter' => '',
  'tagFilter' => '',
  'nextPageToken' => '',
  'maximumPageSize' => '',
  'reverseOrder' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'domain' => '',
  'startTimeFilter' => '',
  'closeTimeFilter' => '',
  'executionFilter' => '',
  'closeStatusFilter' => '',
  'typeFilter' => '',
  'tagFilter' => '',
  'nextPageToken' => '',
  'maximumPageSize' => '',
  'reverseOrder' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "startTimeFilter": "",
  "closeTimeFilter": "",
  "executionFilter": "",
  "closeStatusFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "startTimeFilter": "",
  "closeTimeFilter": "",
  "executionFilter": "",
  "closeStatusFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"closeStatusFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions"

payload = {
    "domain": "",
    "startTimeFilter": "",
    "closeTimeFilter": "",
    "executionFilter": "",
    "closeStatusFilter": "",
    "typeFilter": "",
    "tagFilter": "",
    "nextPageToken": "",
    "maximumPageSize": "",
    "reverseOrder": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions"

payload <- "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"closeStatusFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"closeStatusFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"closeTimeFilter\": \"\",\n  \"executionFilter\": \"\",\n  \"closeStatusFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions";

    let payload = json!({
        "domain": "",
        "startTimeFilter": "",
        "closeTimeFilter": "",
        "executionFilter": "",
        "closeStatusFilter": "",
        "typeFilter": "",
        "tagFilter": "",
        "nextPageToken": "",
        "maximumPageSize": "",
        "reverseOrder": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let 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=SimpleWorkflowService.ListClosedWorkflowExecutions' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "domain": "",
  "startTimeFilter": "",
  "closeTimeFilter": "",
  "executionFilter": "",
  "closeStatusFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}'

echo '{
  "domain": "",
  "startTimeFilter": "",
  "closeTimeFilter": "",
  "executionFilter": "",
  "closeStatusFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "domain": "",\n  "startTimeFilter": "",\n  "closeTimeFilter": "",\n  "executionFilter": "",\n  "closeStatusFilter": "",\n  "typeFilter": "",\n  "tagFilter": "",\n  "nextPageToken": "",\n  "maximumPageSize": "",\n  "reverseOrder": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "domain": "",
  "startTimeFilter": "",
  "closeTimeFilter": "",
  "executionFilter": "",
  "closeStatusFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListClosedWorkflowExecutions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 ListDomains

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains

HEADERS

X-Amz-Target

BODY json

{
  "nextPageToken": "",
  "registrationStatus": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"nextPageToken\": \"\",\n  \"registrationStatus\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains" {:headers {:x-amz-target ""}
                                                                                            :content-type :json
                                                                                            :form-params {:nextPageToken ""
                                                                                                          :registrationStatus ""
                                                                                                          :maximumPageSize ""
                                                                                                          :reverseOrder ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"nextPageToken\": \"\",\n  \"registrationStatus\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"nextPageToken\": \"\",\n  \"registrationStatus\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"nextPageToken\": \"\",\n  \"registrationStatus\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains"

	payload := strings.NewReader("{\n  \"nextPageToken\": \"\",\n  \"registrationStatus\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 100

{
  "nextPageToken": "",
  "registrationStatus": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"nextPageToken\": \"\",\n  \"registrationStatus\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"nextPageToken\": \"\",\n  \"registrationStatus\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"nextPageToken\": \"\",\n  \"registrationStatus\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"nextPageToken\": \"\",\n  \"registrationStatus\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  nextPageToken: '',
  registrationStatus: '',
  maximumPageSize: '',
  reverseOrder: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    nextPageToken: '',
    registrationStatus: '',
    maximumPageSize: '',
    reverseOrder: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"nextPageToken":"","registrationStatus":"","maximumPageSize":"","reverseOrder":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "nextPageToken": "",\n  "registrationStatus": "",\n  "maximumPageSize": "",\n  "reverseOrder": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"nextPageToken\": \"\",\n  \"registrationStatus\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  nextPageToken: '',
  registrationStatus: '',
  maximumPageSize: '',
  reverseOrder: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    nextPageToken: '',
    registrationStatus: '',
    maximumPageSize: '',
    reverseOrder: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  nextPageToken: '',
  registrationStatus: '',
  maximumPageSize: '',
  reverseOrder: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    nextPageToken: '',
    registrationStatus: '',
    maximumPageSize: '',
    reverseOrder: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"nextPageToken":"","registrationStatus":"","maximumPageSize":"","reverseOrder":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"nextPageToken": @"",
                              @"registrationStatus": @"",
                              @"maximumPageSize": @"",
                              @"reverseOrder": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"nextPageToken\": \"\",\n  \"registrationStatus\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'nextPageToken' => '',
    'registrationStatus' => '',
    'maximumPageSize' => '',
    'reverseOrder' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains', [
  'body' => '{
  "nextPageToken": "",
  "registrationStatus": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'nextPageToken' => '',
  'registrationStatus' => '',
  'maximumPageSize' => '',
  'reverseOrder' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'nextPageToken' => '',
  'registrationStatus' => '',
  'maximumPageSize' => '',
  'reverseOrder' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "nextPageToken": "",
  "registrationStatus": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "nextPageToken": "",
  "registrationStatus": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"nextPageToken\": \"\",\n  \"registrationStatus\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains"

payload = {
    "nextPageToken": "",
    "registrationStatus": "",
    "maximumPageSize": "",
    "reverseOrder": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains"

payload <- "{\n  \"nextPageToken\": \"\",\n  \"registrationStatus\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"nextPageToken\": \"\",\n  \"registrationStatus\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"nextPageToken\": \"\",\n  \"registrationStatus\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains";

    let payload = json!({
        "nextPageToken": "",
        "registrationStatus": "",
        "maximumPageSize": "",
        "reverseOrder": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let 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=SimpleWorkflowService.ListDomains' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "nextPageToken": "",
  "registrationStatus": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}'

echo '{
  "nextPageToken": "",
  "registrationStatus": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "nextPageToken": "",\n  "registrationStatus": "",\n  "maximumPageSize": "",\n  "reverseOrder": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "nextPageToken": "",
  "registrationStatus": "",
  "maximumPageSize": "",
  "reverseOrder": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListDomains")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 ListOpenWorkflowExecutions

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions

HEADERS

X-Amz-Target

BODY json

{
  "domain": "",
  "startTimeFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": "",
  "executionFilter": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\",\n  \"executionFilter\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:domain ""
                                                                                                                         :startTimeFilter ""
                                                                                                                         :typeFilter ""
                                                                                                                         :tagFilter ""
                                                                                                                         :nextPageToken ""
                                                                                                                         :maximumPageSize ""
                                                                                                                         :reverseOrder ""
                                                                                                                         :executionFilter ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\",\n  \"executionFilter\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\",\n  \"executionFilter\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\",\n  \"executionFilter\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions"

	payload := strings.NewReader("{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\",\n  \"executionFilter\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 177

{
  "domain": "",
  "startTimeFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": "",
  "executionFilter": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\",\n  \"executionFilter\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\",\n  \"executionFilter\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\",\n  \"executionFilter\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\",\n  \"executionFilter\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  domain: '',
  startTimeFilter: '',
  typeFilter: '',
  tagFilter: '',
  nextPageToken: '',
  maximumPageSize: '',
  reverseOrder: '',
  executionFilter: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    domain: '',
    startTimeFilter: '',
    typeFilter: '',
    tagFilter: '',
    nextPageToken: '',
    maximumPageSize: '',
    reverseOrder: '',
    executionFilter: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","startTimeFilter":"","typeFilter":"","tagFilter":"","nextPageToken":"","maximumPageSize":"","reverseOrder":"","executionFilter":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "domain": "",\n  "startTimeFilter": "",\n  "typeFilter": "",\n  "tagFilter": "",\n  "nextPageToken": "",\n  "maximumPageSize": "",\n  "reverseOrder": "",\n  "executionFilter": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\",\n  \"executionFilter\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  domain: '',
  startTimeFilter: '',
  typeFilter: '',
  tagFilter: '',
  nextPageToken: '',
  maximumPageSize: '',
  reverseOrder: '',
  executionFilter: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    domain: '',
    startTimeFilter: '',
    typeFilter: '',
    tagFilter: '',
    nextPageToken: '',
    maximumPageSize: '',
    reverseOrder: '',
    executionFilter: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  domain: '',
  startTimeFilter: '',
  typeFilter: '',
  tagFilter: '',
  nextPageToken: '',
  maximumPageSize: '',
  reverseOrder: '',
  executionFilter: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    domain: '',
    startTimeFilter: '',
    typeFilter: '',
    tagFilter: '',
    nextPageToken: '',
    maximumPageSize: '',
    reverseOrder: '',
    executionFilter: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","startTimeFilter":"","typeFilter":"","tagFilter":"","nextPageToken":"","maximumPageSize":"","reverseOrder":"","executionFilter":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"domain": @"",
                              @"startTimeFilter": @"",
                              @"typeFilter": @"",
                              @"tagFilter": @"",
                              @"nextPageToken": @"",
                              @"maximumPageSize": @"",
                              @"reverseOrder": @"",
                              @"executionFilter": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\",\n  \"executionFilter\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'domain' => '',
    'startTimeFilter' => '',
    'typeFilter' => '',
    'tagFilter' => '',
    'nextPageToken' => '',
    'maximumPageSize' => '',
    'reverseOrder' => '',
    'executionFilter' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions', [
  'body' => '{
  "domain": "",
  "startTimeFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": "",
  "executionFilter": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'domain' => '',
  'startTimeFilter' => '',
  'typeFilter' => '',
  'tagFilter' => '',
  'nextPageToken' => '',
  'maximumPageSize' => '',
  'reverseOrder' => '',
  'executionFilter' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'domain' => '',
  'startTimeFilter' => '',
  'typeFilter' => '',
  'tagFilter' => '',
  'nextPageToken' => '',
  'maximumPageSize' => '',
  'reverseOrder' => '',
  'executionFilter' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "startTimeFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": "",
  "executionFilter": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "startTimeFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": "",
  "executionFilter": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\",\n  \"executionFilter\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions"

payload = {
    "domain": "",
    "startTimeFilter": "",
    "typeFilter": "",
    "tagFilter": "",
    "nextPageToken": "",
    "maximumPageSize": "",
    "reverseOrder": "",
    "executionFilter": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions"

payload <- "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\",\n  \"executionFilter\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\",\n  \"executionFilter\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"domain\": \"\",\n  \"startTimeFilter\": \"\",\n  \"typeFilter\": \"\",\n  \"tagFilter\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\",\n  \"executionFilter\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions";

    let payload = json!({
        "domain": "",
        "startTimeFilter": "",
        "typeFilter": "",
        "tagFilter": "",
        "nextPageToken": "",
        "maximumPageSize": "",
        "reverseOrder": "",
        "executionFilter": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let 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=SimpleWorkflowService.ListOpenWorkflowExecutions' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "domain": "",
  "startTimeFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": "",
  "executionFilter": ""
}'

echo '{
  "domain": "",
  "startTimeFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": "",
  "executionFilter": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "domain": "",\n  "startTimeFilter": "",\n  "typeFilter": "",\n  "tagFilter": "",\n  "nextPageToken": "",\n  "maximumPageSize": "",\n  "reverseOrder": "",\n  "executionFilter": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "domain": "",
  "startTimeFilter": "",
  "typeFilter": "",
  "tagFilter": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": "",
  "executionFilter": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListOpenWorkflowExecutions")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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=SimpleWorkflowService.ListTagsForResource

HEADERS

X-Amz-Target

BODY json

{
  "resourceArn": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListTagsForResource");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"resourceArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListTagsForResource" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:resourceArn ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListTagsForResource"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"resourceArn\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListTagsForResource"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"resourceArn\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListTagsForResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"resourceArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListTagsForResource"

	payload := strings.NewReader("{\n  \"resourceArn\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 23

{
  "resourceArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListTagsForResource")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"resourceArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListTagsForResource"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"resourceArn\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"resourceArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.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=SimpleWorkflowService.ListTagsForResource")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"resourceArn\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  resourceArn: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.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=SimpleWorkflowService.ListTagsForResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {resourceArn: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListTagsForResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"resourceArn":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListTagsForResource',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "resourceArn": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"resourceArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListTagsForResource")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({resourceArn: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListTagsForResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {resourceArn: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListTagsForResource');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  resourceArn: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListTagsForResource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {resourceArn: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListTagsForResource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"resourceArn":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"resourceArn": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.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=SimpleWorkflowService.ListTagsForResource" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"resourceArn\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListTagsForResource",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'resourceArn' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListTagsForResource', [
  'body' => '{
  "resourceArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListTagsForResource');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'resourceArn' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'resourceArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.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=SimpleWorkflowService.ListTagsForResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceArn": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListTagsForResource' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "resourceArn": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"resourceArn\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListTagsForResource"

payload = { "resourceArn": "" }
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListTagsForResource"

payload <- "{\n  \"resourceArn\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListTagsForResource")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"resourceArn\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"resourceArn\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListTagsForResource";

    let payload = json!({"resourceArn": ""});

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListTagsForResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "resourceArn": ""
}'

echo '{
  "resourceArn": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListTagsForResource' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "resourceArn": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListTagsForResource'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["resourceArn": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.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 ListWorkflowTypes

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes

HEADERS

X-Amz-Target

BODY json

{
  "domain": "",
  "name": "",
  "registrationStatus": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:domain ""
                                                                                                                :name ""
                                                                                                                :registrationStatus ""
                                                                                                                :nextPageToken ""
                                                                                                                :maximumPageSize ""
                                                                                                                :reverseOrder ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes"

	payload := strings.NewReader("{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 130

{
  "domain": "",
  "name": "",
  "registrationStatus": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  domain: '',
  name: '',
  registrationStatus: '',
  nextPageToken: '',
  maximumPageSize: '',
  reverseOrder: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    domain: '',
    name: '',
    registrationStatus: '',
    nextPageToken: '',
    maximumPageSize: '',
    reverseOrder: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","name":"","registrationStatus":"","nextPageToken":"","maximumPageSize":"","reverseOrder":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "domain": "",\n  "name": "",\n  "registrationStatus": "",\n  "nextPageToken": "",\n  "maximumPageSize": "",\n  "reverseOrder": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  domain: '',
  name: '',
  registrationStatus: '',
  nextPageToken: '',
  maximumPageSize: '',
  reverseOrder: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    domain: '',
    name: '',
    registrationStatus: '',
    nextPageToken: '',
    maximumPageSize: '',
    reverseOrder: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  domain: '',
  name: '',
  registrationStatus: '',
  nextPageToken: '',
  maximumPageSize: '',
  reverseOrder: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    domain: '',
    name: '',
    registrationStatus: '',
    nextPageToken: '',
    maximumPageSize: '',
    reverseOrder: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","name":"","registrationStatus":"","nextPageToken":"","maximumPageSize":"","reverseOrder":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"domain": @"",
                              @"name": @"",
                              @"registrationStatus": @"",
                              @"nextPageToken": @"",
                              @"maximumPageSize": @"",
                              @"reverseOrder": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'domain' => '',
    'name' => '',
    'registrationStatus' => '',
    'nextPageToken' => '',
    'maximumPageSize' => '',
    'reverseOrder' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes', [
  'body' => '{
  "domain": "",
  "name": "",
  "registrationStatus": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'domain' => '',
  'name' => '',
  'registrationStatus' => '',
  'nextPageToken' => '',
  'maximumPageSize' => '',
  'reverseOrder' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'domain' => '',
  'name' => '',
  'registrationStatus' => '',
  'nextPageToken' => '',
  'maximumPageSize' => '',
  'reverseOrder' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "name": "",
  "registrationStatus": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "name": "",
  "registrationStatus": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes"

payload = {
    "domain": "",
    "name": "",
    "registrationStatus": "",
    "nextPageToken": "",
    "maximumPageSize": "",
    "reverseOrder": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes"

payload <- "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"registrationStatus\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes";

    let payload = json!({
        "domain": "",
        "name": "",
        "registrationStatus": "",
        "nextPageToken": "",
        "maximumPageSize": "",
        "reverseOrder": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let 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=SimpleWorkflowService.ListWorkflowTypes' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "domain": "",
  "name": "",
  "registrationStatus": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}'

echo '{
  "domain": "",
  "name": "",
  "registrationStatus": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "domain": "",\n  "name": "",\n  "registrationStatus": "",\n  "nextPageToken": "",\n  "maximumPageSize": "",\n  "reverseOrder": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "domain": "",
  "name": "",
  "registrationStatus": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.ListWorkflowTypes")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 PollForActivityTask

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask

HEADERS

X-Amz-Target

BODY json

{
  "domain": "",
  "taskList": "",
  "identity": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:domain ""
                                                                                                                  :taskList ""
                                                                                                                  :identity ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask"

	payload := strings.NewReader("{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 54

{
  "domain": "",
  "taskList": "",
  "identity": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  domain: '',
  taskList: '',
  identity: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {domain: '', taskList: '', identity: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","taskList":"","identity":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "domain": "",\n  "taskList": "",\n  "identity": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({domain: '', taskList: '', identity: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {domain: '', taskList: '', identity: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  domain: '',
  taskList: '',
  identity: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {domain: '', taskList: '', identity: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","taskList":"","identity":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"domain": @"",
                              @"taskList": @"",
                              @"identity": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'domain' => '',
    'taskList' => '',
    'identity' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask', [
  'body' => '{
  "domain": "",
  "taskList": "",
  "identity": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'domain' => '',
  'taskList' => '',
  'identity' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'domain' => '',
  'taskList' => '',
  'identity' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "taskList": "",
  "identity": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "taskList": "",
  "identity": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask"

payload = {
    "domain": "",
    "taskList": "",
    "identity": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask"

payload <- "{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask";

    let payload = json!({
        "domain": "",
        "taskList": "",
        "identity": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let 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=SimpleWorkflowService.PollForActivityTask' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "domain": "",
  "taskList": "",
  "identity": ""
}'

echo '{
  "domain": "",
  "taskList": "",
  "identity": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "domain": "",\n  "taskList": "",\n  "identity": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "domain": "",
  "taskList": "",
  "identity": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForActivityTask")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 PollForDecisionTask

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask

HEADERS

X-Amz-Target

BODY json

{
  "domain": "",
  "taskList": "",
  "identity": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:domain ""
                                                                                                                  :taskList ""
                                                                                                                  :identity ""
                                                                                                                  :nextPageToken ""
                                                                                                                  :maximumPageSize ""
                                                                                                                  :reverseOrder ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask"

	payload := strings.NewReader("{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 124

{
  "domain": "",
  "taskList": "",
  "identity": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  domain: '',
  taskList: '',
  identity: '',
  nextPageToken: '',
  maximumPageSize: '',
  reverseOrder: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    domain: '',
    taskList: '',
    identity: '',
    nextPageToken: '',
    maximumPageSize: '',
    reverseOrder: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","taskList":"","identity":"","nextPageToken":"","maximumPageSize":"","reverseOrder":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "domain": "",\n  "taskList": "",\n  "identity": "",\n  "nextPageToken": "",\n  "maximumPageSize": "",\n  "reverseOrder": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  domain: '',
  taskList: '',
  identity: '',
  nextPageToken: '',
  maximumPageSize: '',
  reverseOrder: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    domain: '',
    taskList: '',
    identity: '',
    nextPageToken: '',
    maximumPageSize: '',
    reverseOrder: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  domain: '',
  taskList: '',
  identity: '',
  nextPageToken: '',
  maximumPageSize: '',
  reverseOrder: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    domain: '',
    taskList: '',
    identity: '',
    nextPageToken: '',
    maximumPageSize: '',
    reverseOrder: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","taskList":"","identity":"","nextPageToken":"","maximumPageSize":"","reverseOrder":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"domain": @"",
                              @"taskList": @"",
                              @"identity": @"",
                              @"nextPageToken": @"",
                              @"maximumPageSize": @"",
                              @"reverseOrder": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'domain' => '',
    'taskList' => '',
    'identity' => '',
    'nextPageToken' => '',
    'maximumPageSize' => '',
    'reverseOrder' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask', [
  'body' => '{
  "domain": "",
  "taskList": "",
  "identity": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'domain' => '',
  'taskList' => '',
  'identity' => '',
  'nextPageToken' => '',
  'maximumPageSize' => '',
  'reverseOrder' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'domain' => '',
  'taskList' => '',
  'identity' => '',
  'nextPageToken' => '',
  'maximumPageSize' => '',
  'reverseOrder' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "taskList": "",
  "identity": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "taskList": "",
  "identity": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask"

payload = {
    "domain": "",
    "taskList": "",
    "identity": "",
    "nextPageToken": "",
    "maximumPageSize": "",
    "reverseOrder": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask"

payload <- "{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"domain\": \"\",\n  \"taskList\": \"\",\n  \"identity\": \"\",\n  \"nextPageToken\": \"\",\n  \"maximumPageSize\": \"\",\n  \"reverseOrder\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask";

    let payload = json!({
        "domain": "",
        "taskList": "",
        "identity": "",
        "nextPageToken": "",
        "maximumPageSize": "",
        "reverseOrder": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let 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=SimpleWorkflowService.PollForDecisionTask' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "domain": "",
  "taskList": "",
  "identity": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}'

echo '{
  "domain": "",
  "taskList": "",
  "identity": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "domain": "",\n  "taskList": "",\n  "identity": "",\n  "nextPageToken": "",\n  "maximumPageSize": "",\n  "reverseOrder": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "domain": "",
  "taskList": "",
  "identity": "",
  "nextPageToken": "",
  "maximumPageSize": "",
  "reverseOrder": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.PollForDecisionTask")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 RecordActivityTaskHeartbeat

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat

HEADERS

X-Amz-Target

BODY json

{
  "taskToken": "",
  "details": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:taskToken ""
                                                                                                                          :details ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat"

	payload := strings.NewReader("{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	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

{
  "taskToken": "",
  "details": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  taskToken: '',
  details: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {taskToken: '', details: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"taskToken":"","details":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "taskToken": "",\n  "details": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({taskToken: '', details: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {taskToken: '', details: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  taskToken: '',
  details: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {taskToken: '', details: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"taskToken":"","details":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"taskToken": @"",
                              @"details": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'taskToken' => '',
    'details' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat', [
  'body' => '{
  "taskToken": "",
  "details": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'taskToken' => '',
  'details' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'taskToken' => '',
  'details' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "taskToken": "",
  "details": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "taskToken": "",
  "details": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat"

payload = {
    "taskToken": "",
    "details": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat"

payload <- "{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat";

    let payload = json!({
        "taskToken": "",
        "details": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let 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=SimpleWorkflowService.RecordActivityTaskHeartbeat' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "taskToken": "",
  "details": ""
}'

echo '{
  "taskToken": "",
  "details": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "taskToken": "",\n  "details": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "taskToken": "",
  "details": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RecordActivityTaskHeartbeat")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 RegisterActivityType

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType

HEADERS

X-Amz-Target

BODY json

{
  "domain": "",
  "name": "",
  "version": "",
  "description": "",
  "defaultTaskStartToCloseTimeout": "",
  "defaultTaskHeartbeatTimeout": "",
  "defaultTaskList": "",
  "defaultTaskPriority": "",
  "defaultTaskScheduleToStartTimeout": "",
  "defaultTaskScheduleToCloseTimeout": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultTaskHeartbeatTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultTaskScheduleToStartTimeout\": \"\",\n  \"defaultTaskScheduleToCloseTimeout\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:domain ""
                                                                                                                   :name ""
                                                                                                                   :version ""
                                                                                                                   :description ""
                                                                                                                   :defaultTaskStartToCloseTimeout ""
                                                                                                                   :defaultTaskHeartbeatTimeout ""
                                                                                                                   :defaultTaskList ""
                                                                                                                   :defaultTaskPriority ""
                                                                                                                   :defaultTaskScheduleToStartTimeout ""
                                                                                                                   :defaultTaskScheduleToCloseTimeout ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultTaskHeartbeatTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultTaskScheduleToStartTimeout\": \"\",\n  \"defaultTaskScheduleToCloseTimeout\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultTaskHeartbeatTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultTaskScheduleToStartTimeout\": \"\",\n  \"defaultTaskScheduleToCloseTimeout\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultTaskHeartbeatTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultTaskScheduleToStartTimeout\": \"\",\n  \"defaultTaskScheduleToCloseTimeout\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType"

	payload := strings.NewReader("{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultTaskHeartbeatTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultTaskScheduleToStartTimeout\": \"\",\n  \"defaultTaskScheduleToCloseTimeout\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 287

{
  "domain": "",
  "name": "",
  "version": "",
  "description": "",
  "defaultTaskStartToCloseTimeout": "",
  "defaultTaskHeartbeatTimeout": "",
  "defaultTaskList": "",
  "defaultTaskPriority": "",
  "defaultTaskScheduleToStartTimeout": "",
  "defaultTaskScheduleToCloseTimeout": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultTaskHeartbeatTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultTaskScheduleToStartTimeout\": \"\",\n  \"defaultTaskScheduleToCloseTimeout\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultTaskHeartbeatTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultTaskScheduleToStartTimeout\": \"\",\n  \"defaultTaskScheduleToCloseTimeout\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultTaskHeartbeatTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultTaskScheduleToStartTimeout\": \"\",\n  \"defaultTaskScheduleToCloseTimeout\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultTaskHeartbeatTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultTaskScheduleToStartTimeout\": \"\",\n  \"defaultTaskScheduleToCloseTimeout\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  domain: '',
  name: '',
  version: '',
  description: '',
  defaultTaskStartToCloseTimeout: '',
  defaultTaskHeartbeatTimeout: '',
  defaultTaskList: '',
  defaultTaskPriority: '',
  defaultTaskScheduleToStartTimeout: '',
  defaultTaskScheduleToCloseTimeout: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    domain: '',
    name: '',
    version: '',
    description: '',
    defaultTaskStartToCloseTimeout: '',
    defaultTaskHeartbeatTimeout: '',
    defaultTaskList: '',
    defaultTaskPriority: '',
    defaultTaskScheduleToStartTimeout: '',
    defaultTaskScheduleToCloseTimeout: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","name":"","version":"","description":"","defaultTaskStartToCloseTimeout":"","defaultTaskHeartbeatTimeout":"","defaultTaskList":"","defaultTaskPriority":"","defaultTaskScheduleToStartTimeout":"","defaultTaskScheduleToCloseTimeout":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "domain": "",\n  "name": "",\n  "version": "",\n  "description": "",\n  "defaultTaskStartToCloseTimeout": "",\n  "defaultTaskHeartbeatTimeout": "",\n  "defaultTaskList": "",\n  "defaultTaskPriority": "",\n  "defaultTaskScheduleToStartTimeout": "",\n  "defaultTaskScheduleToCloseTimeout": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultTaskHeartbeatTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultTaskScheduleToStartTimeout\": \"\",\n  \"defaultTaskScheduleToCloseTimeout\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  domain: '',
  name: '',
  version: '',
  description: '',
  defaultTaskStartToCloseTimeout: '',
  defaultTaskHeartbeatTimeout: '',
  defaultTaskList: '',
  defaultTaskPriority: '',
  defaultTaskScheduleToStartTimeout: '',
  defaultTaskScheduleToCloseTimeout: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    domain: '',
    name: '',
    version: '',
    description: '',
    defaultTaskStartToCloseTimeout: '',
    defaultTaskHeartbeatTimeout: '',
    defaultTaskList: '',
    defaultTaskPriority: '',
    defaultTaskScheduleToStartTimeout: '',
    defaultTaskScheduleToCloseTimeout: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  domain: '',
  name: '',
  version: '',
  description: '',
  defaultTaskStartToCloseTimeout: '',
  defaultTaskHeartbeatTimeout: '',
  defaultTaskList: '',
  defaultTaskPriority: '',
  defaultTaskScheduleToStartTimeout: '',
  defaultTaskScheduleToCloseTimeout: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    domain: '',
    name: '',
    version: '',
    description: '',
    defaultTaskStartToCloseTimeout: '',
    defaultTaskHeartbeatTimeout: '',
    defaultTaskList: '',
    defaultTaskPriority: '',
    defaultTaskScheduleToStartTimeout: '',
    defaultTaskScheduleToCloseTimeout: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","name":"","version":"","description":"","defaultTaskStartToCloseTimeout":"","defaultTaskHeartbeatTimeout":"","defaultTaskList":"","defaultTaskPriority":"","defaultTaskScheduleToStartTimeout":"","defaultTaskScheduleToCloseTimeout":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"domain": @"",
                              @"name": @"",
                              @"version": @"",
                              @"description": @"",
                              @"defaultTaskStartToCloseTimeout": @"",
                              @"defaultTaskHeartbeatTimeout": @"",
                              @"defaultTaskList": @"",
                              @"defaultTaskPriority": @"",
                              @"defaultTaskScheduleToStartTimeout": @"",
                              @"defaultTaskScheduleToCloseTimeout": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultTaskHeartbeatTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultTaskScheduleToStartTimeout\": \"\",\n  \"defaultTaskScheduleToCloseTimeout\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'domain' => '',
    'name' => '',
    'version' => '',
    'description' => '',
    'defaultTaskStartToCloseTimeout' => '',
    'defaultTaskHeartbeatTimeout' => '',
    'defaultTaskList' => '',
    'defaultTaskPriority' => '',
    'defaultTaskScheduleToStartTimeout' => '',
    'defaultTaskScheduleToCloseTimeout' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType', [
  'body' => '{
  "domain": "",
  "name": "",
  "version": "",
  "description": "",
  "defaultTaskStartToCloseTimeout": "",
  "defaultTaskHeartbeatTimeout": "",
  "defaultTaskList": "",
  "defaultTaskPriority": "",
  "defaultTaskScheduleToStartTimeout": "",
  "defaultTaskScheduleToCloseTimeout": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'domain' => '',
  'name' => '',
  'version' => '',
  'description' => '',
  'defaultTaskStartToCloseTimeout' => '',
  'defaultTaskHeartbeatTimeout' => '',
  'defaultTaskList' => '',
  'defaultTaskPriority' => '',
  'defaultTaskScheduleToStartTimeout' => '',
  'defaultTaskScheduleToCloseTimeout' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'domain' => '',
  'name' => '',
  'version' => '',
  'description' => '',
  'defaultTaskStartToCloseTimeout' => '',
  'defaultTaskHeartbeatTimeout' => '',
  'defaultTaskList' => '',
  'defaultTaskPriority' => '',
  'defaultTaskScheduleToStartTimeout' => '',
  'defaultTaskScheduleToCloseTimeout' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "name": "",
  "version": "",
  "description": "",
  "defaultTaskStartToCloseTimeout": "",
  "defaultTaskHeartbeatTimeout": "",
  "defaultTaskList": "",
  "defaultTaskPriority": "",
  "defaultTaskScheduleToStartTimeout": "",
  "defaultTaskScheduleToCloseTimeout": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "name": "",
  "version": "",
  "description": "",
  "defaultTaskStartToCloseTimeout": "",
  "defaultTaskHeartbeatTimeout": "",
  "defaultTaskList": "",
  "defaultTaskPriority": "",
  "defaultTaskScheduleToStartTimeout": "",
  "defaultTaskScheduleToCloseTimeout": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultTaskHeartbeatTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultTaskScheduleToStartTimeout\": \"\",\n  \"defaultTaskScheduleToCloseTimeout\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType"

payload = {
    "domain": "",
    "name": "",
    "version": "",
    "description": "",
    "defaultTaskStartToCloseTimeout": "",
    "defaultTaskHeartbeatTimeout": "",
    "defaultTaskList": "",
    "defaultTaskPriority": "",
    "defaultTaskScheduleToStartTimeout": "",
    "defaultTaskScheduleToCloseTimeout": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType"

payload <- "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultTaskHeartbeatTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultTaskScheduleToStartTimeout\": \"\",\n  \"defaultTaskScheduleToCloseTimeout\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultTaskHeartbeatTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultTaskScheduleToStartTimeout\": \"\",\n  \"defaultTaskScheduleToCloseTimeout\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultTaskHeartbeatTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultTaskScheduleToStartTimeout\": \"\",\n  \"defaultTaskScheduleToCloseTimeout\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType";

    let payload = json!({
        "domain": "",
        "name": "",
        "version": "",
        "description": "",
        "defaultTaskStartToCloseTimeout": "",
        "defaultTaskHeartbeatTimeout": "",
        "defaultTaskList": "",
        "defaultTaskPriority": "",
        "defaultTaskScheduleToStartTimeout": "",
        "defaultTaskScheduleToCloseTimeout": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let 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=SimpleWorkflowService.RegisterActivityType' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "domain": "",
  "name": "",
  "version": "",
  "description": "",
  "defaultTaskStartToCloseTimeout": "",
  "defaultTaskHeartbeatTimeout": "",
  "defaultTaskList": "",
  "defaultTaskPriority": "",
  "defaultTaskScheduleToStartTimeout": "",
  "defaultTaskScheduleToCloseTimeout": ""
}'

echo '{
  "domain": "",
  "name": "",
  "version": "",
  "description": "",
  "defaultTaskStartToCloseTimeout": "",
  "defaultTaskHeartbeatTimeout": "",
  "defaultTaskList": "",
  "defaultTaskPriority": "",
  "defaultTaskScheduleToStartTimeout": "",
  "defaultTaskScheduleToCloseTimeout": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "domain": "",\n  "name": "",\n  "version": "",\n  "description": "",\n  "defaultTaskStartToCloseTimeout": "",\n  "defaultTaskHeartbeatTimeout": "",\n  "defaultTaskList": "",\n  "defaultTaskPriority": "",\n  "defaultTaskScheduleToStartTimeout": "",\n  "defaultTaskScheduleToCloseTimeout": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "domain": "",
  "name": "",
  "version": "",
  "description": "",
  "defaultTaskStartToCloseTimeout": "",
  "defaultTaskHeartbeatTimeout": "",
  "defaultTaskList": "",
  "defaultTaskPriority": "",
  "defaultTaskScheduleToStartTimeout": "",
  "defaultTaskScheduleToCloseTimeout": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterActivityType")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 RegisterDomain

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterDomain

HEADERS

X-Amz-Target

BODY json

{
  "name": "",
  "description": "",
  "workflowExecutionRetentionPeriodInDays": "",
  "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=SimpleWorkflowService.RegisterDomain");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-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  \"description\": \"\",\n  \"workflowExecutionRetentionPeriodInDays\": \"\",\n  \"tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterDomain" {:headers {:x-amz-target ""}
                                                                                               :content-type :json
                                                                                               :form-params {:name ""
                                                                                                             :description ""
                                                                                                             :workflowExecutionRetentionPeriodInDays ""
                                                                                                             :tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterDomain"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"workflowExecutionRetentionPeriodInDays\": \"\",\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=SimpleWorkflowService.RegisterDomain"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"workflowExecutionRetentionPeriodInDays\": \"\",\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=SimpleWorkflowService.RegisterDomain");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"workflowExecutionRetentionPeriodInDays\": \"\",\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=SimpleWorkflowService.RegisterDomain"

	payload := strings.NewReader("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"workflowExecutionRetentionPeriodInDays\": \"\",\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: 99

{
  "name": "",
  "description": "",
  "workflowExecutionRetentionPeriodInDays": "",
  "tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterDomain")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"workflowExecutionRetentionPeriodInDays\": \"\",\n  \"tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterDomain"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"workflowExecutionRetentionPeriodInDays\": \"\",\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  \"name\": \"\",\n  \"description\": \"\",\n  \"workflowExecutionRetentionPeriodInDays\": \"\",\n  \"tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterDomain")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterDomain")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"workflowExecutionRetentionPeriodInDays\": \"\",\n  \"tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  name: '',
  description: '',
  workflowExecutionRetentionPeriodInDays: '',
  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=SimpleWorkflowService.RegisterDomain');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterDomain',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    name: '',
    description: '',
    workflowExecutionRetentionPeriodInDays: '',
    tags: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterDomain';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":"","description":"","workflowExecutionRetentionPeriodInDays":"","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=SimpleWorkflowService.RegisterDomain',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "name": "",\n  "description": "",\n  "workflowExecutionRetentionPeriodInDays": "",\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  \"name\": \"\",\n  \"description\": \"\",\n  \"workflowExecutionRetentionPeriodInDays\": \"\",\n  \"tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterDomain")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.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: '',
  description: '',
  workflowExecutionRetentionPeriodInDays: '',
  tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterDomain',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    name: '',
    description: '',
    workflowExecutionRetentionPeriodInDays: '',
    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=SimpleWorkflowService.RegisterDomain');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  name: '',
  description: '',
  workflowExecutionRetentionPeriodInDays: '',
  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=SimpleWorkflowService.RegisterDomain',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    name: '',
    description: '',
    workflowExecutionRetentionPeriodInDays: '',
    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=SimpleWorkflowService.RegisterDomain';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"name":"","description":"","workflowExecutionRetentionPeriodInDays":"","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 = @{ @"name": @"",
                              @"description": @"",
                              @"workflowExecutionRetentionPeriodInDays": @"",
                              @"tags": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterDomain"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterDomain" 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  \"description\": \"\",\n  \"workflowExecutionRetentionPeriodInDays\": \"\",\n  \"tags\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterDomain",
  CURLOPT_RETURNTRANSFER => 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' => '',
    'description' => '',
    'workflowExecutionRetentionPeriodInDays' => '',
    '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=SimpleWorkflowService.RegisterDomain', [
  'body' => '{
  "name": "",
  "description": "",
  "workflowExecutionRetentionPeriodInDays": "",
  "tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterDomain');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'name' => '',
  'description' => '',
  'workflowExecutionRetentionPeriodInDays' => '',
  'tags' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'name' => '',
  'description' => '',
  'workflowExecutionRetentionPeriodInDays' => '',
  'tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterDomain');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterDomain' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "description": "",
  "workflowExecutionRetentionPeriodInDays": "",
  "tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterDomain' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "name": "",
  "description": "",
  "workflowExecutionRetentionPeriodInDays": "",
  "tags": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"workflowExecutionRetentionPeriodInDays\": \"\",\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=SimpleWorkflowService.RegisterDomain"

payload = {
    "name": "",
    "description": "",
    "workflowExecutionRetentionPeriodInDays": "",
    "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=SimpleWorkflowService.RegisterDomain"

payload <- "{\n  \"name\": \"\",\n  \"description\": \"\",\n  \"workflowExecutionRetentionPeriodInDays\": \"\",\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=SimpleWorkflowService.RegisterDomain")

http = Net::HTTP.new(url.host, 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  \"description\": \"\",\n  \"workflowExecutionRetentionPeriodInDays\": \"\",\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  \"name\": \"\",\n  \"description\": \"\",\n  \"workflowExecutionRetentionPeriodInDays\": \"\",\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=SimpleWorkflowService.RegisterDomain";

    let payload = json!({
        "name": "",
        "description": "",
        "workflowExecutionRetentionPeriodInDays": "",
        "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=SimpleWorkflowService.RegisterDomain' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "name": "",
  "description": "",
  "workflowExecutionRetentionPeriodInDays": "",
  "tags": ""
}'

echo '{
  "name": "",
  "description": "",
  "workflowExecutionRetentionPeriodInDays": "",
  "tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterDomain' \
  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  "description": "",\n  "workflowExecutionRetentionPeriodInDays": "",\n  "tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterDomain'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "name": "",
  "description": "",
  "workflowExecutionRetentionPeriodInDays": "",
  "tags": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterDomain")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 RegisterWorkflowType

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType

HEADERS

X-Amz-Target

BODY json

{
  "domain": "",
  "name": "",
  "version": "",
  "description": "",
  "defaultTaskStartToCloseTimeout": "",
  "defaultExecutionStartToCloseTimeout": "",
  "defaultTaskList": "",
  "defaultTaskPriority": "",
  "defaultChildPolicy": "",
  "defaultLambdaRole": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultExecutionStartToCloseTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultChildPolicy\": \"\",\n  \"defaultLambdaRole\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:domain ""
                                                                                                                   :name ""
                                                                                                                   :version ""
                                                                                                                   :description ""
                                                                                                                   :defaultTaskStartToCloseTimeout ""
                                                                                                                   :defaultExecutionStartToCloseTimeout ""
                                                                                                                   :defaultTaskList ""
                                                                                                                   :defaultTaskPriority ""
                                                                                                                   :defaultChildPolicy ""
                                                                                                                   :defaultLambdaRole ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultExecutionStartToCloseTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultChildPolicy\": \"\",\n  \"defaultLambdaRole\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultExecutionStartToCloseTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultChildPolicy\": \"\",\n  \"defaultLambdaRole\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultExecutionStartToCloseTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultChildPolicy\": \"\",\n  \"defaultLambdaRole\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType"

	payload := strings.NewReader("{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultExecutionStartToCloseTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultChildPolicy\": \"\",\n  \"defaultLambdaRole\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 264

{
  "domain": "",
  "name": "",
  "version": "",
  "description": "",
  "defaultTaskStartToCloseTimeout": "",
  "defaultExecutionStartToCloseTimeout": "",
  "defaultTaskList": "",
  "defaultTaskPriority": "",
  "defaultChildPolicy": "",
  "defaultLambdaRole": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultExecutionStartToCloseTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultChildPolicy\": \"\",\n  \"defaultLambdaRole\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultExecutionStartToCloseTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultChildPolicy\": \"\",\n  \"defaultLambdaRole\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultExecutionStartToCloseTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultChildPolicy\": \"\",\n  \"defaultLambdaRole\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultExecutionStartToCloseTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultChildPolicy\": \"\",\n  \"defaultLambdaRole\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  domain: '',
  name: '',
  version: '',
  description: '',
  defaultTaskStartToCloseTimeout: '',
  defaultExecutionStartToCloseTimeout: '',
  defaultTaskList: '',
  defaultTaskPriority: '',
  defaultChildPolicy: '',
  defaultLambdaRole: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    domain: '',
    name: '',
    version: '',
    description: '',
    defaultTaskStartToCloseTimeout: '',
    defaultExecutionStartToCloseTimeout: '',
    defaultTaskList: '',
    defaultTaskPriority: '',
    defaultChildPolicy: '',
    defaultLambdaRole: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","name":"","version":"","description":"","defaultTaskStartToCloseTimeout":"","defaultExecutionStartToCloseTimeout":"","defaultTaskList":"","defaultTaskPriority":"","defaultChildPolicy":"","defaultLambdaRole":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "domain": "",\n  "name": "",\n  "version": "",\n  "description": "",\n  "defaultTaskStartToCloseTimeout": "",\n  "defaultExecutionStartToCloseTimeout": "",\n  "defaultTaskList": "",\n  "defaultTaskPriority": "",\n  "defaultChildPolicy": "",\n  "defaultLambdaRole": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultExecutionStartToCloseTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultChildPolicy\": \"\",\n  \"defaultLambdaRole\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  domain: '',
  name: '',
  version: '',
  description: '',
  defaultTaskStartToCloseTimeout: '',
  defaultExecutionStartToCloseTimeout: '',
  defaultTaskList: '',
  defaultTaskPriority: '',
  defaultChildPolicy: '',
  defaultLambdaRole: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    domain: '',
    name: '',
    version: '',
    description: '',
    defaultTaskStartToCloseTimeout: '',
    defaultExecutionStartToCloseTimeout: '',
    defaultTaskList: '',
    defaultTaskPriority: '',
    defaultChildPolicy: '',
    defaultLambdaRole: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  domain: '',
  name: '',
  version: '',
  description: '',
  defaultTaskStartToCloseTimeout: '',
  defaultExecutionStartToCloseTimeout: '',
  defaultTaskList: '',
  defaultTaskPriority: '',
  defaultChildPolicy: '',
  defaultLambdaRole: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    domain: '',
    name: '',
    version: '',
    description: '',
    defaultTaskStartToCloseTimeout: '',
    defaultExecutionStartToCloseTimeout: '',
    defaultTaskList: '',
    defaultTaskPriority: '',
    defaultChildPolicy: '',
    defaultLambdaRole: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","name":"","version":"","description":"","defaultTaskStartToCloseTimeout":"","defaultExecutionStartToCloseTimeout":"","defaultTaskList":"","defaultTaskPriority":"","defaultChildPolicy":"","defaultLambdaRole":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"domain": @"",
                              @"name": @"",
                              @"version": @"",
                              @"description": @"",
                              @"defaultTaskStartToCloseTimeout": @"",
                              @"defaultExecutionStartToCloseTimeout": @"",
                              @"defaultTaskList": @"",
                              @"defaultTaskPriority": @"",
                              @"defaultChildPolicy": @"",
                              @"defaultLambdaRole": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultExecutionStartToCloseTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultChildPolicy\": \"\",\n  \"defaultLambdaRole\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'domain' => '',
    'name' => '',
    'version' => '',
    'description' => '',
    'defaultTaskStartToCloseTimeout' => '',
    'defaultExecutionStartToCloseTimeout' => '',
    'defaultTaskList' => '',
    'defaultTaskPriority' => '',
    'defaultChildPolicy' => '',
    'defaultLambdaRole' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType', [
  'body' => '{
  "domain": "",
  "name": "",
  "version": "",
  "description": "",
  "defaultTaskStartToCloseTimeout": "",
  "defaultExecutionStartToCloseTimeout": "",
  "defaultTaskList": "",
  "defaultTaskPriority": "",
  "defaultChildPolicy": "",
  "defaultLambdaRole": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'domain' => '',
  'name' => '',
  'version' => '',
  'description' => '',
  'defaultTaskStartToCloseTimeout' => '',
  'defaultExecutionStartToCloseTimeout' => '',
  'defaultTaskList' => '',
  'defaultTaskPriority' => '',
  'defaultChildPolicy' => '',
  'defaultLambdaRole' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'domain' => '',
  'name' => '',
  'version' => '',
  'description' => '',
  'defaultTaskStartToCloseTimeout' => '',
  'defaultExecutionStartToCloseTimeout' => '',
  'defaultTaskList' => '',
  'defaultTaskPriority' => '',
  'defaultChildPolicy' => '',
  'defaultLambdaRole' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "name": "",
  "version": "",
  "description": "",
  "defaultTaskStartToCloseTimeout": "",
  "defaultExecutionStartToCloseTimeout": "",
  "defaultTaskList": "",
  "defaultTaskPriority": "",
  "defaultChildPolicy": "",
  "defaultLambdaRole": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "name": "",
  "version": "",
  "description": "",
  "defaultTaskStartToCloseTimeout": "",
  "defaultExecutionStartToCloseTimeout": "",
  "defaultTaskList": "",
  "defaultTaskPriority": "",
  "defaultChildPolicy": "",
  "defaultLambdaRole": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultExecutionStartToCloseTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultChildPolicy\": \"\",\n  \"defaultLambdaRole\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType"

payload = {
    "domain": "",
    "name": "",
    "version": "",
    "description": "",
    "defaultTaskStartToCloseTimeout": "",
    "defaultExecutionStartToCloseTimeout": "",
    "defaultTaskList": "",
    "defaultTaskPriority": "",
    "defaultChildPolicy": "",
    "defaultLambdaRole": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType"

payload <- "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultExecutionStartToCloseTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultChildPolicy\": \"\",\n  \"defaultLambdaRole\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultExecutionStartToCloseTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultChildPolicy\": \"\",\n  \"defaultLambdaRole\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"domain\": \"\",\n  \"name\": \"\",\n  \"version\": \"\",\n  \"description\": \"\",\n  \"defaultTaskStartToCloseTimeout\": \"\",\n  \"defaultExecutionStartToCloseTimeout\": \"\",\n  \"defaultTaskList\": \"\",\n  \"defaultTaskPriority\": \"\",\n  \"defaultChildPolicy\": \"\",\n  \"defaultLambdaRole\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType";

    let payload = json!({
        "domain": "",
        "name": "",
        "version": "",
        "description": "",
        "defaultTaskStartToCloseTimeout": "",
        "defaultExecutionStartToCloseTimeout": "",
        "defaultTaskList": "",
        "defaultTaskPriority": "",
        "defaultChildPolicy": "",
        "defaultLambdaRole": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let 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=SimpleWorkflowService.RegisterWorkflowType' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "domain": "",
  "name": "",
  "version": "",
  "description": "",
  "defaultTaskStartToCloseTimeout": "",
  "defaultExecutionStartToCloseTimeout": "",
  "defaultTaskList": "",
  "defaultTaskPriority": "",
  "defaultChildPolicy": "",
  "defaultLambdaRole": ""
}'

echo '{
  "domain": "",
  "name": "",
  "version": "",
  "description": "",
  "defaultTaskStartToCloseTimeout": "",
  "defaultExecutionStartToCloseTimeout": "",
  "defaultTaskList": "",
  "defaultTaskPriority": "",
  "defaultChildPolicy": "",
  "defaultLambdaRole": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "domain": "",\n  "name": "",\n  "version": "",\n  "description": "",\n  "defaultTaskStartToCloseTimeout": "",\n  "defaultExecutionStartToCloseTimeout": "",\n  "defaultTaskList": "",\n  "defaultTaskPriority": "",\n  "defaultChildPolicy": "",\n  "defaultLambdaRole": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "domain": "",
  "name": "",
  "version": "",
  "description": "",
  "defaultTaskStartToCloseTimeout": "",
  "defaultExecutionStartToCloseTimeout": "",
  "defaultTaskList": "",
  "defaultTaskPriority": "",
  "defaultChildPolicy": "",
  "defaultLambdaRole": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RegisterWorkflowType")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 RequestCancelWorkflowExecution

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution

HEADERS

X-Amz-Target

BODY json

{
  "domain": "",
  "workflowId": "",
  "runId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:domain ""
                                                                                                                             :workflowId ""
                                                                                                                             :runId ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution"

	payload := strings.NewReader("{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 53

{
  "domain": "",
  "workflowId": "",
  "runId": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  domain: '',
  workflowId: '',
  runId: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {domain: '', workflowId: '', runId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","workflowId":"","runId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "domain": "",\n  "workflowId": "",\n  "runId": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({domain: '', workflowId: '', runId: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {domain: '', workflowId: '', runId: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  domain: '',
  workflowId: '',
  runId: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {domain: '', workflowId: '', runId: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","workflowId":"","runId":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"domain": @"",
                              @"workflowId": @"",
                              @"runId": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'domain' => '',
    'workflowId' => '',
    'runId' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution', [
  'body' => '{
  "domain": "",
  "workflowId": "",
  "runId": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'domain' => '',
  'workflowId' => '',
  'runId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'domain' => '',
  'workflowId' => '',
  'runId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "workflowId": "",
  "runId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "workflowId": "",
  "runId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution"

payload = {
    "domain": "",
    "workflowId": "",
    "runId": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution"

payload <- "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution";

    let payload = json!({
        "domain": "",
        "workflowId": "",
        "runId": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let 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=SimpleWorkflowService.RequestCancelWorkflowExecution' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "domain": "",
  "workflowId": "",
  "runId": ""
}'

echo '{
  "domain": "",
  "workflowId": "",
  "runId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "domain": "",\n  "workflowId": "",\n  "runId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "domain": "",
  "workflowId": "",
  "runId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RequestCancelWorkflowExecution")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 RespondActivityTaskCanceled

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled

HEADERS

X-Amz-Target

BODY json

{
  "taskToken": "",
  "details": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:taskToken ""
                                                                                                                          :details ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled"

	payload := strings.NewReader("{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	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

{
  "taskToken": "",
  "details": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  taskToken: '',
  details: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {taskToken: '', details: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"taskToken":"","details":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "taskToken": "",\n  "details": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({taskToken: '', details: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {taskToken: '', details: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  taskToken: '',
  details: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {taskToken: '', details: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"taskToken":"","details":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"taskToken": @"",
                              @"details": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'taskToken' => '',
    'details' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled', [
  'body' => '{
  "taskToken": "",
  "details": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'taskToken' => '',
  'details' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'taskToken' => '',
  'details' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "taskToken": "",
  "details": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "taskToken": "",
  "details": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled"

payload = {
    "taskToken": "",
    "details": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled"

payload <- "{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"taskToken\": \"\",\n  \"details\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled";

    let payload = json!({
        "taskToken": "",
        "details": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let 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=SimpleWorkflowService.RespondActivityTaskCanceled' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "taskToken": "",
  "details": ""
}'

echo '{
  "taskToken": "",
  "details": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "taskToken": "",\n  "details": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "taskToken": "",
  "details": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCanceled")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 RespondActivityTaskCompleted

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted

HEADERS

X-Amz-Target

BODY json

{
  "taskToken": "",
  "result": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"taskToken\": \"\",\n  \"result\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:taskToken ""
                                                                                                                           :result ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"taskToken\": \"\",\n  \"result\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"taskToken\": \"\",\n  \"result\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"taskToken\": \"\",\n  \"result\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted"

	payload := strings.NewReader("{\n  \"taskToken\": \"\",\n  \"result\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	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

{
  "taskToken": "",
  "result": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"taskToken\": \"\",\n  \"result\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"taskToken\": \"\",\n  \"result\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"taskToken\": \"\",\n  \"result\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"taskToken\": \"\",\n  \"result\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  taskToken: '',
  result: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {taskToken: '', result: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"taskToken":"","result":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "taskToken": "",\n  "result": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"taskToken\": \"\",\n  \"result\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({taskToken: '', result: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {taskToken: '', result: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  taskToken: '',
  result: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {taskToken: '', result: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"taskToken":"","result":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"taskToken": @"",
                              @"result": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"taskToken\": \"\",\n  \"result\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'taskToken' => '',
    'result' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted', [
  'body' => '{
  "taskToken": "",
  "result": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'taskToken' => '',
  'result' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'taskToken' => '',
  'result' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "taskToken": "",
  "result": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "taskToken": "",
  "result": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"taskToken\": \"\",\n  \"result\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted"

payload = {
    "taskToken": "",
    "result": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted"

payload <- "{\n  \"taskToken\": \"\",\n  \"result\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"taskToken\": \"\",\n  \"result\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"taskToken\": \"\",\n  \"result\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted";

    let payload = json!({
        "taskToken": "",
        "result": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let 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=SimpleWorkflowService.RespondActivityTaskCompleted' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "taskToken": "",
  "result": ""
}'

echo '{
  "taskToken": "",
  "result": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "taskToken": "",\n  "result": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "taskToken": "",
  "result": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskCompleted")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 RespondActivityTaskFailed

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed

HEADERS

X-Amz-Target

BODY json

{
  "taskToken": "",
  "reason": "",
  "details": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"taskToken\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:taskToken ""
                                                                                                                        :reason ""
                                                                                                                        :details ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"taskToken\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"taskToken\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"taskToken\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed"

	payload := strings.NewReader("{\n  \"taskToken\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 54

{
  "taskToken": "",
  "reason": "",
  "details": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"taskToken\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"taskToken\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"taskToken\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"taskToken\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  taskToken: '',
  reason: '',
  details: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {taskToken: '', reason: '', details: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"taskToken":"","reason":"","details":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "taskToken": "",\n  "reason": "",\n  "details": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"taskToken\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({taskToken: '', reason: '', details: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {taskToken: '', reason: '', details: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  taskToken: '',
  reason: '',
  details: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {taskToken: '', reason: '', details: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"taskToken":"","reason":"","details":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"taskToken": @"",
                              @"reason": @"",
                              @"details": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"taskToken\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'taskToken' => '',
    'reason' => '',
    'details' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed', [
  'body' => '{
  "taskToken": "",
  "reason": "",
  "details": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'taskToken' => '',
  'reason' => '',
  'details' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'taskToken' => '',
  'reason' => '',
  'details' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "taskToken": "",
  "reason": "",
  "details": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "taskToken": "",
  "reason": "",
  "details": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"taskToken\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed"

payload = {
    "taskToken": "",
    "reason": "",
    "details": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed"

payload <- "{\n  \"taskToken\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"taskToken\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"taskToken\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed";

    let payload = json!({
        "taskToken": "",
        "reason": "",
        "details": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let 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=SimpleWorkflowService.RespondActivityTaskFailed' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "taskToken": "",
  "reason": "",
  "details": ""
}'

echo '{
  "taskToken": "",
  "reason": "",
  "details": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "taskToken": "",\n  "reason": "",\n  "details": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "taskToken": "",
  "reason": "",
  "details": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondActivityTaskFailed")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 RespondDecisionTaskCompleted

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted

HEADERS

X-Amz-Target

BODY json

{
  "taskToken": "",
  "decisions": "",
  "executionContext": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"taskToken\": \"\",\n  \"decisions\": \"\",\n  \"executionContext\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:taskToken ""
                                                                                                                           :decisions ""
                                                                                                                           :executionContext ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"taskToken\": \"\",\n  \"decisions\": \"\",\n  \"executionContext\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"taskToken\": \"\",\n  \"decisions\": \"\",\n  \"executionContext\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"taskToken\": \"\",\n  \"decisions\": \"\",\n  \"executionContext\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted"

	payload := strings.NewReader("{\n  \"taskToken\": \"\",\n  \"decisions\": \"\",\n  \"executionContext\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 66

{
  "taskToken": "",
  "decisions": "",
  "executionContext": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"taskToken\": \"\",\n  \"decisions\": \"\",\n  \"executionContext\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"taskToken\": \"\",\n  \"decisions\": \"\",\n  \"executionContext\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"taskToken\": \"\",\n  \"decisions\": \"\",\n  \"executionContext\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"taskToken\": \"\",\n  \"decisions\": \"\",\n  \"executionContext\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  taskToken: '',
  decisions: '',
  executionContext: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {taskToken: '', decisions: '', executionContext: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"taskToken":"","decisions":"","executionContext":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "taskToken": "",\n  "decisions": "",\n  "executionContext": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"taskToken\": \"\",\n  \"decisions\": \"\",\n  \"executionContext\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({taskToken: '', decisions: '', executionContext: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {taskToken: '', decisions: '', executionContext: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  taskToken: '',
  decisions: '',
  executionContext: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {taskToken: '', decisions: '', executionContext: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"taskToken":"","decisions":"","executionContext":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"taskToken": @"",
                              @"decisions": @"",
                              @"executionContext": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"taskToken\": \"\",\n  \"decisions\": \"\",\n  \"executionContext\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'taskToken' => '',
    'decisions' => '',
    'executionContext' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted', [
  'body' => '{
  "taskToken": "",
  "decisions": "",
  "executionContext": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'taskToken' => '',
  'decisions' => '',
  'executionContext' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'taskToken' => '',
  'decisions' => '',
  'executionContext' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "taskToken": "",
  "decisions": "",
  "executionContext": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "taskToken": "",
  "decisions": "",
  "executionContext": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"taskToken\": \"\",\n  \"decisions\": \"\",\n  \"executionContext\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted"

payload = {
    "taskToken": "",
    "decisions": "",
    "executionContext": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted"

payload <- "{\n  \"taskToken\": \"\",\n  \"decisions\": \"\",\n  \"executionContext\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"taskToken\": \"\",\n  \"decisions\": \"\",\n  \"executionContext\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"taskToken\": \"\",\n  \"decisions\": \"\",\n  \"executionContext\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted";

    let payload = json!({
        "taskToken": "",
        "decisions": "",
        "executionContext": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let 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=SimpleWorkflowService.RespondDecisionTaskCompleted' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "taskToken": "",
  "decisions": "",
  "executionContext": ""
}'

echo '{
  "taskToken": "",
  "decisions": "",
  "executionContext": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "taskToken": "",\n  "decisions": "",\n  "executionContext": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "taskToken": "",
  "decisions": "",
  "executionContext": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.RespondDecisionTaskCompleted")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 SignalWorkflowExecution

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution

HEADERS

X-Amz-Target

BODY json

{
  "domain": "",
  "workflowId": "",
  "runId": "",
  "signalName": "",
  "input": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"signalName\": \"\",\n  \"input\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:domain ""
                                                                                                                      :workflowId ""
                                                                                                                      :runId ""
                                                                                                                      :signalName ""
                                                                                                                      :input ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"signalName\": \"\",\n  \"input\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"signalName\": \"\",\n  \"input\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"signalName\": \"\",\n  \"input\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution"

	payload := strings.NewReader("{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"signalName\": \"\",\n  \"input\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	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

{
  "domain": "",
  "workflowId": "",
  "runId": "",
  "signalName": "",
  "input": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"signalName\": \"\",\n  \"input\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"signalName\": \"\",\n  \"input\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"signalName\": \"\",\n  \"input\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"signalName\": \"\",\n  \"input\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  domain: '',
  workflowId: '',
  runId: '',
  signalName: '',
  input: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {domain: '', workflowId: '', runId: '', signalName: '', input: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","workflowId":"","runId":"","signalName":"","input":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "domain": "",\n  "workflowId": "",\n  "runId": "",\n  "signalName": "",\n  "input": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"signalName\": \"\",\n  \"input\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({domain: '', workflowId: '', runId: '', signalName: '', input: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {domain: '', workflowId: '', runId: '', signalName: '', input: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  domain: '',
  workflowId: '',
  runId: '',
  signalName: '',
  input: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {domain: '', workflowId: '', runId: '', signalName: '', input: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","workflowId":"","runId":"","signalName":"","input":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"domain": @"",
                              @"workflowId": @"",
                              @"runId": @"",
                              @"signalName": @"",
                              @"input": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"signalName\": \"\",\n  \"input\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'domain' => '',
    'workflowId' => '',
    'runId' => '',
    'signalName' => '',
    'input' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution', [
  'body' => '{
  "domain": "",
  "workflowId": "",
  "runId": "",
  "signalName": "",
  "input": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'domain' => '',
  'workflowId' => '',
  'runId' => '',
  'signalName' => '',
  'input' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'domain' => '',
  'workflowId' => '',
  'runId' => '',
  'signalName' => '',
  'input' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "workflowId": "",
  "runId": "",
  "signalName": "",
  "input": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "workflowId": "",
  "runId": "",
  "signalName": "",
  "input": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"signalName\": \"\",\n  \"input\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution"

payload = {
    "domain": "",
    "workflowId": "",
    "runId": "",
    "signalName": "",
    "input": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution"

payload <- "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"signalName\": \"\",\n  \"input\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"signalName\": \"\",\n  \"input\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"signalName\": \"\",\n  \"input\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution";

    let payload = json!({
        "domain": "",
        "workflowId": "",
        "runId": "",
        "signalName": "",
        "input": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let 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=SimpleWorkflowService.SignalWorkflowExecution' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "domain": "",
  "workflowId": "",
  "runId": "",
  "signalName": "",
  "input": ""
}'

echo '{
  "domain": "",
  "workflowId": "",
  "runId": "",
  "signalName": "",
  "input": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "domain": "",\n  "workflowId": "",\n  "runId": "",\n  "signalName": "",\n  "input": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "domain": "",
  "workflowId": "",
  "runId": "",
  "signalName": "",
  "input": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.SignalWorkflowExecution")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 StartWorkflowExecution

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution

HEADERS

X-Amz-Target

BODY json

{
  "domain": "",
  "workflowId": "",
  "workflowType": "",
  "taskList": "",
  "taskPriority": "",
  "input": "",
  "executionStartToCloseTimeout": "",
  "tagList": "",
  "taskStartToCloseTimeout": "",
  "childPolicy": "",
  "lambdaRole": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"workflowType\": \"\",\n  \"taskList\": \"\",\n  \"taskPriority\": \"\",\n  \"input\": \"\",\n  \"executionStartToCloseTimeout\": \"\",\n  \"tagList\": \"\",\n  \"taskStartToCloseTimeout\": \"\",\n  \"childPolicy\": \"\",\n  \"lambdaRole\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution" {:headers {:x-amz-target ""}
                                                                                                       :content-type :json
                                                                                                       :form-params {:domain ""
                                                                                                                     :workflowId ""
                                                                                                                     :workflowType ""
                                                                                                                     :taskList ""
                                                                                                                     :taskPriority ""
                                                                                                                     :input ""
                                                                                                                     :executionStartToCloseTimeout ""
                                                                                                                     :tagList ""
                                                                                                                     :taskStartToCloseTimeout ""
                                                                                                                     :childPolicy ""
                                                                                                                     :lambdaRole ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"workflowType\": \"\",\n  \"taskList\": \"\",\n  \"taskPriority\": \"\",\n  \"input\": \"\",\n  \"executionStartToCloseTimeout\": \"\",\n  \"tagList\": \"\",\n  \"taskStartToCloseTimeout\": \"\",\n  \"childPolicy\": \"\",\n  \"lambdaRole\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"workflowType\": \"\",\n  \"taskList\": \"\",\n  \"taskPriority\": \"\",\n  \"input\": \"\",\n  \"executionStartToCloseTimeout\": \"\",\n  \"tagList\": \"\",\n  \"taskStartToCloseTimeout\": \"\",\n  \"childPolicy\": \"\",\n  \"lambdaRole\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"workflowType\": \"\",\n  \"taskList\": \"\",\n  \"taskPriority\": \"\",\n  \"input\": \"\",\n  \"executionStartToCloseTimeout\": \"\",\n  \"tagList\": \"\",\n  \"taskStartToCloseTimeout\": \"\",\n  \"childPolicy\": \"\",\n  \"lambdaRole\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution"

	payload := strings.NewReader("{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"workflowType\": \"\",\n  \"taskList\": \"\",\n  \"taskPriority\": \"\",\n  \"input\": \"\",\n  \"executionStartToCloseTimeout\": \"\",\n  \"tagList\": \"\",\n  \"taskStartToCloseTimeout\": \"\",\n  \"childPolicy\": \"\",\n  \"lambdaRole\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 244

{
  "domain": "",
  "workflowId": "",
  "workflowType": "",
  "taskList": "",
  "taskPriority": "",
  "input": "",
  "executionStartToCloseTimeout": "",
  "tagList": "",
  "taskStartToCloseTimeout": "",
  "childPolicy": "",
  "lambdaRole": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"workflowType\": \"\",\n  \"taskList\": \"\",\n  \"taskPriority\": \"\",\n  \"input\": \"\",\n  \"executionStartToCloseTimeout\": \"\",\n  \"tagList\": \"\",\n  \"taskStartToCloseTimeout\": \"\",\n  \"childPolicy\": \"\",\n  \"lambdaRole\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"workflowType\": \"\",\n  \"taskList\": \"\",\n  \"taskPriority\": \"\",\n  \"input\": \"\",\n  \"executionStartToCloseTimeout\": \"\",\n  \"tagList\": \"\",\n  \"taskStartToCloseTimeout\": \"\",\n  \"childPolicy\": \"\",\n  \"lambdaRole\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"workflowType\": \"\",\n  \"taskList\": \"\",\n  \"taskPriority\": \"\",\n  \"input\": \"\",\n  \"executionStartToCloseTimeout\": \"\",\n  \"tagList\": \"\",\n  \"taskStartToCloseTimeout\": \"\",\n  \"childPolicy\": \"\",\n  \"lambdaRole\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"workflowType\": \"\",\n  \"taskList\": \"\",\n  \"taskPriority\": \"\",\n  \"input\": \"\",\n  \"executionStartToCloseTimeout\": \"\",\n  \"tagList\": \"\",\n  \"taskStartToCloseTimeout\": \"\",\n  \"childPolicy\": \"\",\n  \"lambdaRole\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  domain: '',
  workflowId: '',
  workflowType: '',
  taskList: '',
  taskPriority: '',
  input: '',
  executionStartToCloseTimeout: '',
  tagList: '',
  taskStartToCloseTimeout: '',
  childPolicy: '',
  lambdaRole: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    domain: '',
    workflowId: '',
    workflowType: '',
    taskList: '',
    taskPriority: '',
    input: '',
    executionStartToCloseTimeout: '',
    tagList: '',
    taskStartToCloseTimeout: '',
    childPolicy: '',
    lambdaRole: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","workflowId":"","workflowType":"","taskList":"","taskPriority":"","input":"","executionStartToCloseTimeout":"","tagList":"","taskStartToCloseTimeout":"","childPolicy":"","lambdaRole":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "domain": "",\n  "workflowId": "",\n  "workflowType": "",\n  "taskList": "",\n  "taskPriority": "",\n  "input": "",\n  "executionStartToCloseTimeout": "",\n  "tagList": "",\n  "taskStartToCloseTimeout": "",\n  "childPolicy": "",\n  "lambdaRole": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"workflowType\": \"\",\n  \"taskList\": \"\",\n  \"taskPriority\": \"\",\n  \"input\": \"\",\n  \"executionStartToCloseTimeout\": \"\",\n  \"tagList\": \"\",\n  \"taskStartToCloseTimeout\": \"\",\n  \"childPolicy\": \"\",\n  \"lambdaRole\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  domain: '',
  workflowId: '',
  workflowType: '',
  taskList: '',
  taskPriority: '',
  input: '',
  executionStartToCloseTimeout: '',
  tagList: '',
  taskStartToCloseTimeout: '',
  childPolicy: '',
  lambdaRole: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    domain: '',
    workflowId: '',
    workflowType: '',
    taskList: '',
    taskPriority: '',
    input: '',
    executionStartToCloseTimeout: '',
    tagList: '',
    taskStartToCloseTimeout: '',
    childPolicy: '',
    lambdaRole: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  domain: '',
  workflowId: '',
  workflowType: '',
  taskList: '',
  taskPriority: '',
  input: '',
  executionStartToCloseTimeout: '',
  tagList: '',
  taskStartToCloseTimeout: '',
  childPolicy: '',
  lambdaRole: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    domain: '',
    workflowId: '',
    workflowType: '',
    taskList: '',
    taskPriority: '',
    input: '',
    executionStartToCloseTimeout: '',
    tagList: '',
    taskStartToCloseTimeout: '',
    childPolicy: '',
    lambdaRole: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","workflowId":"","workflowType":"","taskList":"","taskPriority":"","input":"","executionStartToCloseTimeout":"","tagList":"","taskStartToCloseTimeout":"","childPolicy":"","lambdaRole":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"domain": @"",
                              @"workflowId": @"",
                              @"workflowType": @"",
                              @"taskList": @"",
                              @"taskPriority": @"",
                              @"input": @"",
                              @"executionStartToCloseTimeout": @"",
                              @"tagList": @"",
                              @"taskStartToCloseTimeout": @"",
                              @"childPolicy": @"",
                              @"lambdaRole": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"workflowType\": \"\",\n  \"taskList\": \"\",\n  \"taskPriority\": \"\",\n  \"input\": \"\",\n  \"executionStartToCloseTimeout\": \"\",\n  \"tagList\": \"\",\n  \"taskStartToCloseTimeout\": \"\",\n  \"childPolicy\": \"\",\n  \"lambdaRole\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'domain' => '',
    'workflowId' => '',
    'workflowType' => '',
    'taskList' => '',
    'taskPriority' => '',
    'input' => '',
    'executionStartToCloseTimeout' => '',
    'tagList' => '',
    'taskStartToCloseTimeout' => '',
    'childPolicy' => '',
    'lambdaRole' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution', [
  'body' => '{
  "domain": "",
  "workflowId": "",
  "workflowType": "",
  "taskList": "",
  "taskPriority": "",
  "input": "",
  "executionStartToCloseTimeout": "",
  "tagList": "",
  "taskStartToCloseTimeout": "",
  "childPolicy": "",
  "lambdaRole": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'domain' => '',
  'workflowId' => '',
  'workflowType' => '',
  'taskList' => '',
  'taskPriority' => '',
  'input' => '',
  'executionStartToCloseTimeout' => '',
  'tagList' => '',
  'taskStartToCloseTimeout' => '',
  'childPolicy' => '',
  'lambdaRole' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'domain' => '',
  'workflowId' => '',
  'workflowType' => '',
  'taskList' => '',
  'taskPriority' => '',
  'input' => '',
  'executionStartToCloseTimeout' => '',
  'tagList' => '',
  'taskStartToCloseTimeout' => '',
  'childPolicy' => '',
  'lambdaRole' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "workflowId": "",
  "workflowType": "",
  "taskList": "",
  "taskPriority": "",
  "input": "",
  "executionStartToCloseTimeout": "",
  "tagList": "",
  "taskStartToCloseTimeout": "",
  "childPolicy": "",
  "lambdaRole": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "workflowId": "",
  "workflowType": "",
  "taskList": "",
  "taskPriority": "",
  "input": "",
  "executionStartToCloseTimeout": "",
  "tagList": "",
  "taskStartToCloseTimeout": "",
  "childPolicy": "",
  "lambdaRole": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"workflowType\": \"\",\n  \"taskList\": \"\",\n  \"taskPriority\": \"\",\n  \"input\": \"\",\n  \"executionStartToCloseTimeout\": \"\",\n  \"tagList\": \"\",\n  \"taskStartToCloseTimeout\": \"\",\n  \"childPolicy\": \"\",\n  \"lambdaRole\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution"

payload = {
    "domain": "",
    "workflowId": "",
    "workflowType": "",
    "taskList": "",
    "taskPriority": "",
    "input": "",
    "executionStartToCloseTimeout": "",
    "tagList": "",
    "taskStartToCloseTimeout": "",
    "childPolicy": "",
    "lambdaRole": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution"

payload <- "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"workflowType\": \"\",\n  \"taskList\": \"\",\n  \"taskPriority\": \"\",\n  \"input\": \"\",\n  \"executionStartToCloseTimeout\": \"\",\n  \"tagList\": \"\",\n  \"taskStartToCloseTimeout\": \"\",\n  \"childPolicy\": \"\",\n  \"lambdaRole\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"workflowType\": \"\",\n  \"taskList\": \"\",\n  \"taskPriority\": \"\",\n  \"input\": \"\",\n  \"executionStartToCloseTimeout\": \"\",\n  \"tagList\": \"\",\n  \"taskStartToCloseTimeout\": \"\",\n  \"childPolicy\": \"\",\n  \"lambdaRole\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"workflowType\": \"\",\n  \"taskList\": \"\",\n  \"taskPriority\": \"\",\n  \"input\": \"\",\n  \"executionStartToCloseTimeout\": \"\",\n  \"tagList\": \"\",\n  \"taskStartToCloseTimeout\": \"\",\n  \"childPolicy\": \"\",\n  \"lambdaRole\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution";

    let payload = json!({
        "domain": "",
        "workflowId": "",
        "workflowType": "",
        "taskList": "",
        "taskPriority": "",
        "input": "",
        "executionStartToCloseTimeout": "",
        "tagList": "",
        "taskStartToCloseTimeout": "",
        "childPolicy": "",
        "lambdaRole": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let 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=SimpleWorkflowService.StartWorkflowExecution' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "domain": "",
  "workflowId": "",
  "workflowType": "",
  "taskList": "",
  "taskPriority": "",
  "input": "",
  "executionStartToCloseTimeout": "",
  "tagList": "",
  "taskStartToCloseTimeout": "",
  "childPolicy": "",
  "lambdaRole": ""
}'

echo '{
  "domain": "",
  "workflowId": "",
  "workflowType": "",
  "taskList": "",
  "taskPriority": "",
  "input": "",
  "executionStartToCloseTimeout": "",
  "tagList": "",
  "taskStartToCloseTimeout": "",
  "childPolicy": "",
  "lambdaRole": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "domain": "",\n  "workflowId": "",\n  "workflowType": "",\n  "taskList": "",\n  "taskPriority": "",\n  "input": "",\n  "executionStartToCloseTimeout": "",\n  "tagList": "",\n  "taskStartToCloseTimeout": "",\n  "childPolicy": "",\n  "lambdaRole": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "domain": "",
  "workflowId": "",
  "workflowType": "",
  "taskList": "",
  "taskPriority": "",
  "input": "",
  "executionStartToCloseTimeout": "",
  "tagList": "",
  "taskStartToCloseTimeout": "",
  "childPolicy": "",
  "lambdaRole": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.StartWorkflowExecution")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.TagResource" {:headers {:x-amz-target ""}
                                                                                            :content-type :json
                                                                                            :form-params {:resourceArn ""
                                                                                                          :tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.TagResource', [
  'body' => '{
  "resourceArn": "",
  "tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.TagResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "resourceArn": "",
  "tags": ""
}'

echo '{
  "resourceArn": "",
  "tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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 TerminateWorkflowExecution

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution

HEADERS

X-Amz-Target

BODY json

{
  "domain": "",
  "workflowId": "",
  "runId": "",
  "reason": "",
  "details": "",
  "childPolicy": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\",\n  \"childPolicy\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:domain ""
                                                                                                                         :workflowId ""
                                                                                                                         :runId ""
                                                                                                                         :reason ""
                                                                                                                         :details ""
                                                                                                                         :childPolicy ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\",\n  \"childPolicy\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\",\n  \"childPolicy\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\",\n  \"childPolicy\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution"

	payload := strings.NewReader("{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\",\n  \"childPolicy\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 107

{
  "domain": "",
  "workflowId": "",
  "runId": "",
  "reason": "",
  "details": "",
  "childPolicy": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\",\n  \"childPolicy\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\",\n  \"childPolicy\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\",\n  \"childPolicy\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\",\n  \"childPolicy\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  domain: '',
  workflowId: '',
  runId: '',
  reason: '',
  details: '',
  childPolicy: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    domain: '',
    workflowId: '',
    runId: '',
    reason: '',
    details: '',
    childPolicy: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","workflowId":"","runId":"","reason":"","details":"","childPolicy":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "domain": "",\n  "workflowId": "",\n  "runId": "",\n  "reason": "",\n  "details": "",\n  "childPolicy": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\",\n  \"childPolicy\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  domain: '',
  workflowId: '',
  runId: '',
  reason: '',
  details: '',
  childPolicy: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    domain: '',
    workflowId: '',
    runId: '',
    reason: '',
    details: '',
    childPolicy: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  domain: '',
  workflowId: '',
  runId: '',
  reason: '',
  details: '',
  childPolicy: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    domain: '',
    workflowId: '',
    runId: '',
    reason: '',
    details: '',
    childPolicy: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","workflowId":"","runId":"","reason":"","details":"","childPolicy":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"domain": @"",
                              @"workflowId": @"",
                              @"runId": @"",
                              @"reason": @"",
                              @"details": @"",
                              @"childPolicy": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\",\n  \"childPolicy\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'domain' => '',
    'workflowId' => '',
    'runId' => '',
    'reason' => '',
    'details' => '',
    'childPolicy' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution', [
  'body' => '{
  "domain": "",
  "workflowId": "",
  "runId": "",
  "reason": "",
  "details": "",
  "childPolicy": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'domain' => '',
  'workflowId' => '',
  'runId' => '',
  'reason' => '',
  'details' => '',
  'childPolicy' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'domain' => '',
  'workflowId' => '',
  'runId' => '',
  'reason' => '',
  'details' => '',
  'childPolicy' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "workflowId": "",
  "runId": "",
  "reason": "",
  "details": "",
  "childPolicy": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "workflowId": "",
  "runId": "",
  "reason": "",
  "details": "",
  "childPolicy": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\",\n  \"childPolicy\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution"

payload = {
    "domain": "",
    "workflowId": "",
    "runId": "",
    "reason": "",
    "details": "",
    "childPolicy": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution"

payload <- "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\",\n  \"childPolicy\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\",\n  \"childPolicy\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"domain\": \"\",\n  \"workflowId\": \"\",\n  \"runId\": \"\",\n  \"reason\": \"\",\n  \"details\": \"\",\n  \"childPolicy\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution";

    let payload = json!({
        "domain": "",
        "workflowId": "",
        "runId": "",
        "reason": "",
        "details": "",
        "childPolicy": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let 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=SimpleWorkflowService.TerminateWorkflowExecution' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "domain": "",
  "workflowId": "",
  "runId": "",
  "reason": "",
  "details": "",
  "childPolicy": ""
}'

echo '{
  "domain": "",
  "workflowId": "",
  "runId": "",
  "reason": "",
  "details": "",
  "childPolicy": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "domain": "",\n  "workflowId": "",\n  "runId": "",\n  "reason": "",\n  "details": "",\n  "childPolicy": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "domain": "",
  "workflowId": "",
  "runId": "",
  "reason": "",
  "details": "",
  "childPolicy": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.TerminateWorkflowExecution")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 UndeprecateActivityType

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType

HEADERS

X-Amz-Target

BODY json

{
  "domain": "",
  "activityType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:domain ""
                                                                                                                      :activityType ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType"

	payload := strings.NewReader("{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	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

{
  "domain": "",
  "activityType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  domain: '',
  activityType: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {domain: '', activityType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","activityType":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "domain": "",\n  "activityType": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({domain: '', activityType: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {domain: '', activityType: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  domain: '',
  activityType: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {domain: '', activityType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","activityType":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"domain": @"",
                              @"activityType": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'domain' => '',
    'activityType' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType', [
  'body' => '{
  "domain": "",
  "activityType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'domain' => '',
  'activityType' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'domain' => '',
  'activityType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "activityType": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "activityType": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType"

payload = {
    "domain": "",
    "activityType": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType"

payload <- "{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"domain\": \"\",\n  \"activityType\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType";

    let payload = json!({
        "domain": "",
        "activityType": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let 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=SimpleWorkflowService.UndeprecateActivityType' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "domain": "",
  "activityType": ""
}'

echo '{
  "domain": "",
  "activityType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "domain": "",\n  "activityType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "domain": "",
  "activityType": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateActivityType")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 UndeprecateDomain

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateDomain

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=SimpleWorkflowService.UndeprecateDomain");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-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=SimpleWorkflowService.UndeprecateDomain" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:name ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateDomain"
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=SimpleWorkflowService.UndeprecateDomain"),
    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=SimpleWorkflowService.UndeprecateDomain");
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=SimpleWorkflowService.UndeprecateDomain"

	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=SimpleWorkflowService.UndeprecateDomain")
  .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=SimpleWorkflowService.UndeprecateDomain"))
    .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=SimpleWorkflowService.UndeprecateDomain")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateDomain")
  .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=SimpleWorkflowService.UndeprecateDomain');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateDomain',
  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=SimpleWorkflowService.UndeprecateDomain';
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=SimpleWorkflowService.UndeprecateDomain',
  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=SimpleWorkflowService.UndeprecateDomain")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.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=SimpleWorkflowService.UndeprecateDomain',
  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=SimpleWorkflowService.UndeprecateDomain');

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=SimpleWorkflowService.UndeprecateDomain',
  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=SimpleWorkflowService.UndeprecateDomain';
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=SimpleWorkflowService.UndeprecateDomain"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateDomain" 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=SimpleWorkflowService.UndeprecateDomain",
  CURLOPT_RETURNTRANSFER => 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=SimpleWorkflowService.UndeprecateDomain', [
  'body' => '{
  "name": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateDomain');
$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=SimpleWorkflowService.UndeprecateDomain');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateDomain' -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=SimpleWorkflowService.UndeprecateDomain' -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=SimpleWorkflowService.UndeprecateDomain"

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=SimpleWorkflowService.UndeprecateDomain"

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=SimpleWorkflowService.UndeprecateDomain")

http = Net::HTTP.new(url.host, 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=SimpleWorkflowService.UndeprecateDomain";

    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=SimpleWorkflowService.UndeprecateDomain' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "name": ""
}'

echo '{
  "name": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateDomain' \
  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=SimpleWorkflowService.UndeprecateDomain'

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=SimpleWorkflowService.UndeprecateDomain")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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 UndeprecateWorkflowType

{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType

HEADERS

X-Amz-Target

BODY json

{
  "domain": "",
  "workflowType": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:domain ""
                                                                                                                      :workflowType ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType"

	payload := strings.NewReader("{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	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

{
  "domain": "",
  "workflowType": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build();

Response response = client.newCall(request).execute();

HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  domain: '',
  workflowType: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType');
xhr.setRequestHeader('x-amz-target', '');
xhr.setRequestHeader('content-type', 'application/json');

xhr.send(data);

import axios from 'axios';

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {domain: '', workflowType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","workflowType":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "domain": "",\n  "workflowType": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({domain: '', workflowType: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {domain: '', workflowType: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  domain: '',
  workflowType: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {domain: '', workflowType: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"domain":"","workflowType":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"domain": @"",
                              @"workflowType": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType"]
                                                       cachePolicy:NSURLRequestUseProtocolCachePolicy
                                                   timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];

NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
                                            completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
                                                if (error) {
                                                    NSLog(@"%@", error);
                                                } else {
                                                    NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
                                                    NSLog(@"%@", httpResponse);
                                                }
                                            }];
[dataTask resume];

open Cohttp_lwt_unix
open Cohttp
open Lwt

let uri = Uri.of_string "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'domain' => '',
    'workflowType' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType', [
  'body' => '{
  "domain": "",
  "workflowType": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'domain' => '',
  'workflowType' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'domain' => '',
  'workflowType' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType');
$request->setRequestMethod('POST');
$request->setBody($body);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$client->enqueue($request)->send();
$response = $client->getResponse();

echo $response->getBody();

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "workflowType": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "domain": "",
  "workflowType": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType"

payload = {
    "domain": "",
    "workflowType": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType"

payload <- "{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"domain\": \"\",\n  \"workflowType\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType";

    let payload = json!({
        "domain": "",
        "workflowType": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let 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=SimpleWorkflowService.UndeprecateWorkflowType' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "domain": "",
  "workflowType": ""
}'

echo '{
  "domain": "",
  "workflowType": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "domain": "",\n  "workflowType": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "domain": "",
  "workflowType": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.UndeprecateWorkflowType")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as 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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.UntagResource" {:headers {:x-amz-target ""}
                                                                                              :content-type :json
                                                                                              :form-params {:resourceArn ""
                                                                                                            :tagKeys ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.UntagResource', [
  'body' => '{
  "resourceArn": "",
  "tagKeys": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.UntagResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "resourceArn": "",
  "tagKeys": ""
}'

echo '{
  "resourceArn": "",
  "tagKeys": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=SimpleWorkflowService.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=SimpleWorkflowService.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=SimpleWorkflowService.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()