Amazon Kinesis Analytics (amazonaws.com) – OpenAPI Spec, Docs & Bruno Collection

POST AddApplicationCloudWatchLoggingOption

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationCloudWatchLoggingOption

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "CloudWatchLoggingOption": "",
  "ConditionalToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"CloudWatchLoggingOption\": \"\",\n  \"ConditionalToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationCloudWatchLoggingOption" {:headers {:x-amz-target ""}
                                                                                                                          :content-type :json
                                                                                                                          :form-params {:ApplicationName ""
                                                                                                                                        :CurrentApplicationVersionId ""
                                                                                                                                        :CloudWatchLoggingOption ""
                                                                                                                                        :ConditionalToken ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationCloudWatchLoggingOption"

	payload := strings.NewReader("{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"CloudWatchLoggingOption\": \"\",\n  \"ConditionalToken\": \"\"\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: 123

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "CloudWatchLoggingOption": "",
  "ConditionalToken": ""
}

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

client.close();

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

const data = JSON.stringify({
  ApplicationName: '',
  CurrentApplicationVersionId: '',
  CloudWatchLoggingOption: '',
  ConditionalToken: ''
});

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=KinesisAnalytics_20180523.AddApplicationCloudWatchLoggingOption');
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=KinesisAnalytics_20180523.AddApplicationCloudWatchLoggingOption',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ApplicationName: '',
    CurrentApplicationVersionId: '',
    CloudWatchLoggingOption: '',
    ConditionalToken: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationCloudWatchLoggingOption';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","CurrentApplicationVersionId":"","CloudWatchLoggingOption":"","ConditionalToken":""}'
};

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=KinesisAnalytics_20180523.AddApplicationCloudWatchLoggingOption',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ApplicationName": "",\n  "CurrentApplicationVersionId": "",\n  "CloudWatchLoggingOption": "",\n  "ConditionalToken": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  ApplicationName: '',
  CurrentApplicationVersionId: '',
  CloudWatchLoggingOption: '',
  ConditionalToken: ''
});

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=KinesisAnalytics_20180523.AddApplicationCloudWatchLoggingOption',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ApplicationName: '',
    CurrentApplicationVersionId: '',
    CloudWatchLoggingOption: '',
    ConditionalToken: ''
  }
};

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=KinesisAnalytics_20180523.AddApplicationCloudWatchLoggingOption';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","CurrentApplicationVersionId":"","CloudWatchLoggingOption":"","ConditionalToken":""}'
};

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 = @{ @"ApplicationName": @"",
                              @"CurrentApplicationVersionId": @"",
                              @"CloudWatchLoggingOption": @"",
                              @"ConditionalToken": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ApplicationName' => '',
  'CurrentApplicationVersionId' => '',
  'CloudWatchLoggingOption' => '',
  'ConditionalToken' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"CloudWatchLoggingOption\": \"\",\n  \"ConditionalToken\": \"\"\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=KinesisAnalytics_20180523.AddApplicationCloudWatchLoggingOption"

payload = {
    "ApplicationName": "",
    "CurrentApplicationVersionId": "",
    "CloudWatchLoggingOption": "",
    "ConditionalToken": ""
}
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=KinesisAnalytics_20180523.AddApplicationCloudWatchLoggingOption"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"CloudWatchLoggingOption\": \"\",\n  \"ConditionalToken\": \"\"\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=KinesisAnalytics_20180523.AddApplicationCloudWatchLoggingOption")

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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"CloudWatchLoggingOption\": \"\",\n  \"ConditionalToken\": \"\"\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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"CloudWatchLoggingOption\": \"\",\n  \"ConditionalToken\": \"\"\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=KinesisAnalytics_20180523.AddApplicationCloudWatchLoggingOption";

    let payload = json!({
        "ApplicationName": "",
        "CurrentApplicationVersionId": "",
        "CloudWatchLoggingOption": "",
        "ConditionalToken": ""
    });

    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=KinesisAnalytics_20180523.AddApplicationCloudWatchLoggingOption' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "CloudWatchLoggingOption": "",
  "ConditionalToken": ""
}'

echo '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "CloudWatchLoggingOption": "",
  "ConditionalToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationCloudWatchLoggingOption' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ApplicationName": "",\n  "CurrentApplicationVersionId": "",\n  "CloudWatchLoggingOption": "",\n  "ConditionalToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationCloudWatchLoggingOption'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationInput

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "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=KinesisAnalytics_20180523.AddApplicationInput");

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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"Input\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationInput" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:ApplicationName ""
                                                                                                                      :CurrentApplicationVersionId ""
                                                                                                                      :Input ""}})

require "http/client"

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

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

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "Input": ""
}

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

client.close();

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

const data = JSON.stringify({
  ApplicationName: '',
  CurrentApplicationVersionId: '',
  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=KinesisAnalytics_20180523.AddApplicationInput');
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=KinesisAnalytics_20180523.AddApplicationInput',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', CurrentApplicationVersionId: '', Input: ''}
};

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

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

const request = require('request');

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

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

req.type('json');
req.send({
  ApplicationName: '',
  CurrentApplicationVersionId: '',
  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=KinesisAnalytics_20180523.AddApplicationInput',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', CurrentApplicationVersionId: '', 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=KinesisAnalytics_20180523.AddApplicationInput';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","CurrentApplicationVersionId":"","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 = @{ @"ApplicationName": @"",
                              @"CurrentApplicationVersionId": @"",
                              @"Input": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ApplicationName' => '',
  'CurrentApplicationVersionId' => '',
  'Input' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\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=KinesisAnalytics_20180523.AddApplicationInput"

payload = {
    "ApplicationName": "",
    "CurrentApplicationVersionId": "",
    "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=KinesisAnalytics_20180523.AddApplicationInput"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\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=KinesisAnalytics_20180523.AddApplicationInput")

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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\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=KinesisAnalytics_20180523.AddApplicationInput";

    let payload = json!({
        "ApplicationName": "",
        "CurrentApplicationVersionId": "",
        "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=KinesisAnalytics_20180523.AddApplicationInput' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "Input": ""
}'

echo '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "Input": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationInput' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ApplicationName": "",\n  "CurrentApplicationVersionId": "",\n  "Input": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationInput'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationInputProcessingConfiguration

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "InputId": "",
  "InputProcessingConfiguration": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"InputId\": \"\",\n  \"InputProcessingConfiguration\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationInputProcessingConfiguration" {:headers {:x-amz-target ""}
                                                                                                                               :content-type :json
                                                                                                                               :form-params {:ApplicationName ""
                                                                                                                                             :CurrentApplicationVersionId ""
                                                                                                                                             :InputId ""
                                                                                                                                             :InputProcessingConfiguration ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationInputProcessingConfiguration"

	payload := strings.NewReader("{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"InputId\": \"\",\n  \"InputProcessingConfiguration\": \"\"\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: 119

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "InputId": "",
  "InputProcessingConfiguration": ""
}

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

client.close();

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

const data = JSON.stringify({
  ApplicationName: '',
  CurrentApplicationVersionId: '',
  InputId: '',
  InputProcessingConfiguration: ''
});

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=KinesisAnalytics_20180523.AddApplicationInputProcessingConfiguration');
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=KinesisAnalytics_20180523.AddApplicationInputProcessingConfiguration',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ApplicationName: '',
    CurrentApplicationVersionId: '',
    InputId: '',
    InputProcessingConfiguration: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationInputProcessingConfiguration';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","CurrentApplicationVersionId":"","InputId":"","InputProcessingConfiguration":""}'
};

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=KinesisAnalytics_20180523.AddApplicationInputProcessingConfiguration',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ApplicationName": "",\n  "CurrentApplicationVersionId": "",\n  "InputId": "",\n  "InputProcessingConfiguration": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  ApplicationName: '',
  CurrentApplicationVersionId: '',
  InputId: '',
  InputProcessingConfiguration: ''
});

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=KinesisAnalytics_20180523.AddApplicationInputProcessingConfiguration',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ApplicationName: '',
    CurrentApplicationVersionId: '',
    InputId: '',
    InputProcessingConfiguration: ''
  }
};

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=KinesisAnalytics_20180523.AddApplicationInputProcessingConfiguration';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","CurrentApplicationVersionId":"","InputId":"","InputProcessingConfiguration":""}'
};

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 = @{ @"ApplicationName": @"",
                              @"CurrentApplicationVersionId": @"",
                              @"InputId": @"",
                              @"InputProcessingConfiguration": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ApplicationName' => '',
  'CurrentApplicationVersionId' => '',
  'InputId' => '',
  'InputProcessingConfiguration' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"InputId\": \"\",\n  \"InputProcessingConfiguration\": \"\"\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=KinesisAnalytics_20180523.AddApplicationInputProcessingConfiguration"

payload = {
    "ApplicationName": "",
    "CurrentApplicationVersionId": "",
    "InputId": "",
    "InputProcessingConfiguration": ""
}
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=KinesisAnalytics_20180523.AddApplicationInputProcessingConfiguration"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"InputId\": \"\",\n  \"InputProcessingConfiguration\": \"\"\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=KinesisAnalytics_20180523.AddApplicationInputProcessingConfiguration")

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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"InputId\": \"\",\n  \"InputProcessingConfiguration\": \"\"\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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"InputId\": \"\",\n  \"InputProcessingConfiguration\": \"\"\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=KinesisAnalytics_20180523.AddApplicationInputProcessingConfiguration";

    let payload = json!({
        "ApplicationName": "",
        "CurrentApplicationVersionId": "",
        "InputId": "",
        "InputProcessingConfiguration": ""
    });

    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=KinesisAnalytics_20180523.AddApplicationInputProcessingConfiguration' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "InputId": "",
  "InputProcessingConfiguration": ""
}'

echo '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "InputId": "",
  "InputProcessingConfiguration": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationInputProcessingConfiguration' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ApplicationName": "",\n  "CurrentApplicationVersionId": "",\n  "InputId": "",\n  "InputProcessingConfiguration": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationInputProcessingConfiguration'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationOutput

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "Output": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"Output\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationOutput" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:ApplicationName ""
                                                                                                                       :CurrentApplicationVersionId ""
                                                                                                                       :Output ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationOutput"

	payload := strings.NewReader("{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"Output\": \"\"\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: 80

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "Output": ""
}

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

client.close();

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

const data = JSON.stringify({
  ApplicationName: '',
  CurrentApplicationVersionId: '',
  Output: ''
});

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=KinesisAnalytics_20180523.AddApplicationOutput');
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=KinesisAnalytics_20180523.AddApplicationOutput',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', CurrentApplicationVersionId: '', Output: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationOutput';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","CurrentApplicationVersionId":"","Output":""}'
};

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  ApplicationName: '',
  CurrentApplicationVersionId: '',
  Output: ''
});

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=KinesisAnalytics_20180523.AddApplicationOutput',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', CurrentApplicationVersionId: '', Output: ''}
};

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=KinesisAnalytics_20180523.AddApplicationOutput';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","CurrentApplicationVersionId":"","Output":""}'
};

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 = @{ @"ApplicationName": @"",
                              @"CurrentApplicationVersionId": @"",
                              @"Output": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ApplicationName' => '',
  'CurrentApplicationVersionId' => '',
  'Output' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"Output\": \"\"\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=KinesisAnalytics_20180523.AddApplicationOutput"

payload = {
    "ApplicationName": "",
    "CurrentApplicationVersionId": "",
    "Output": ""
}
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=KinesisAnalytics_20180523.AddApplicationOutput"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"Output\": \"\"\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=KinesisAnalytics_20180523.AddApplicationOutput")

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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"Output\": \"\"\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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"Output\": \"\"\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=KinesisAnalytics_20180523.AddApplicationOutput";

    let payload = json!({
        "ApplicationName": "",
        "CurrentApplicationVersionId": "",
        "Output": ""
    });

    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=KinesisAnalytics_20180523.AddApplicationOutput' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "Output": ""
}'

echo '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "Output": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationOutput' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ApplicationName": "",\n  "CurrentApplicationVersionId": "",\n  "Output": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationOutput'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationReferenceDataSource

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "ReferenceDataSource": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ReferenceDataSource\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationReferenceDataSource" {:headers {:x-amz-target ""}
                                                                                                                      :content-type :json
                                                                                                                      :form-params {:ApplicationName ""
                                                                                                                                    :CurrentApplicationVersionId ""
                                                                                                                                    :ReferenceDataSource ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationReferenceDataSource"

	payload := strings.NewReader("{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ReferenceDataSource\": \"\"\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: 93

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "ReferenceDataSource": ""
}

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

client.close();

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

const data = JSON.stringify({
  ApplicationName: '',
  CurrentApplicationVersionId: '',
  ReferenceDataSource: ''
});

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=KinesisAnalytics_20180523.AddApplicationReferenceDataSource');
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=KinesisAnalytics_20180523.AddApplicationReferenceDataSource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', CurrentApplicationVersionId: '', ReferenceDataSource: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationReferenceDataSource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","CurrentApplicationVersionId":"","ReferenceDataSource":""}'
};

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  ApplicationName: '',
  CurrentApplicationVersionId: '',
  ReferenceDataSource: ''
});

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=KinesisAnalytics_20180523.AddApplicationReferenceDataSource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', CurrentApplicationVersionId: '', ReferenceDataSource: ''}
};

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=KinesisAnalytics_20180523.AddApplicationReferenceDataSource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","CurrentApplicationVersionId":"","ReferenceDataSource":""}'
};

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 = @{ @"ApplicationName": @"",
                              @"CurrentApplicationVersionId": @"",
                              @"ReferenceDataSource": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ApplicationName' => '',
  'CurrentApplicationVersionId' => '',
  'ReferenceDataSource' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ReferenceDataSource\": \"\"\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=KinesisAnalytics_20180523.AddApplicationReferenceDataSource"

payload = {
    "ApplicationName": "",
    "CurrentApplicationVersionId": "",
    "ReferenceDataSource": ""
}
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=KinesisAnalytics_20180523.AddApplicationReferenceDataSource"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ReferenceDataSource\": \"\"\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=KinesisAnalytics_20180523.AddApplicationReferenceDataSource")

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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ReferenceDataSource\": \"\"\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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ReferenceDataSource\": \"\"\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=KinesisAnalytics_20180523.AddApplicationReferenceDataSource";

    let payload = json!({
        "ApplicationName": "",
        "CurrentApplicationVersionId": "",
        "ReferenceDataSource": ""
    });

    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=KinesisAnalytics_20180523.AddApplicationReferenceDataSource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "ReferenceDataSource": ""
}'

echo '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "ReferenceDataSource": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationReferenceDataSource' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ApplicationName": "",\n  "CurrentApplicationVersionId": "",\n  "ReferenceDataSource": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationReferenceDataSource'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationVpcConfiguration

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "VpcConfiguration": "",
  "ConditionalToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"VpcConfiguration\": \"\",\n  \"ConditionalToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationVpcConfiguration" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:ApplicationName ""
                                                                                                                                 :CurrentApplicationVersionId ""
                                                                                                                                 :VpcConfiguration ""
                                                                                                                                 :ConditionalToken ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationVpcConfiguration"

	payload := strings.NewReader("{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"VpcConfiguration\": \"\",\n  \"ConditionalToken\": \"\"\n}")

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

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

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

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

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

}

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

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "VpcConfiguration": "",
  "ConditionalToken": ""
}

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

client.close();

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

const data = JSON.stringify({
  ApplicationName: '',
  CurrentApplicationVersionId: '',
  VpcConfiguration: '',
  ConditionalToken: ''
});

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=KinesisAnalytics_20180523.AddApplicationVpcConfiguration');
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=KinesisAnalytics_20180523.AddApplicationVpcConfiguration',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ApplicationName: '',
    CurrentApplicationVersionId: '',
    VpcConfiguration: '',
    ConditionalToken: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationVpcConfiguration';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","CurrentApplicationVersionId":"","VpcConfiguration":"","ConditionalToken":""}'
};

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=KinesisAnalytics_20180523.AddApplicationVpcConfiguration',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ApplicationName": "",\n  "CurrentApplicationVersionId": "",\n  "VpcConfiguration": "",\n  "ConditionalToken": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  ApplicationName: '',
  CurrentApplicationVersionId: '',
  VpcConfiguration: '',
  ConditionalToken: ''
});

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=KinesisAnalytics_20180523.AddApplicationVpcConfiguration',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ApplicationName: '',
    CurrentApplicationVersionId: '',
    VpcConfiguration: '',
    ConditionalToken: ''
  }
};

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=KinesisAnalytics_20180523.AddApplicationVpcConfiguration';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","CurrentApplicationVersionId":"","VpcConfiguration":"","ConditionalToken":""}'
};

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 = @{ @"ApplicationName": @"",
                              @"CurrentApplicationVersionId": @"",
                              @"VpcConfiguration": @"",
                              @"ConditionalToken": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ApplicationName' => '',
  'CurrentApplicationVersionId' => '',
  'VpcConfiguration' => '',
  'ConditionalToken' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"VpcConfiguration\": \"\",\n  \"ConditionalToken\": \"\"\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=KinesisAnalytics_20180523.AddApplicationVpcConfiguration"

payload = {
    "ApplicationName": "",
    "CurrentApplicationVersionId": "",
    "VpcConfiguration": "",
    "ConditionalToken": ""
}
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=KinesisAnalytics_20180523.AddApplicationVpcConfiguration"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"VpcConfiguration\": \"\",\n  \"ConditionalToken\": \"\"\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=KinesisAnalytics_20180523.AddApplicationVpcConfiguration")

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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"VpcConfiguration\": \"\",\n  \"ConditionalToken\": \"\"\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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"VpcConfiguration\": \"\",\n  \"ConditionalToken\": \"\"\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=KinesisAnalytics_20180523.AddApplicationVpcConfiguration";

    let payload = json!({
        "ApplicationName": "",
        "CurrentApplicationVersionId": "",
        "VpcConfiguration": "",
        "ConditionalToken": ""
    });

    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=KinesisAnalytics_20180523.AddApplicationVpcConfiguration' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "VpcConfiguration": "",
  "ConditionalToken": ""
}'

echo '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "VpcConfiguration": "",
  "ConditionalToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationVpcConfiguration' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ApplicationName": "",\n  "CurrentApplicationVersionId": "",\n  "VpcConfiguration": "",\n  "ConditionalToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.AddApplicationVpcConfiguration'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.CreateApplication

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "ApplicationDescription": "",
  "RuntimeEnvironment": "",
  "ServiceExecutionRole": "",
  "ApplicationConfiguration": "",
  "CloudWatchLoggingOptions": "",
  "Tags": "",
  "ApplicationMode": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"ApplicationName\": \"\",\n  \"ApplicationDescription\": \"\",\n  \"RuntimeEnvironment\": \"\",\n  \"ServiceExecutionRole\": \"\",\n  \"ApplicationConfiguration\": \"\",\n  \"CloudWatchLoggingOptions\": \"\",\n  \"Tags\": \"\",\n  \"ApplicationMode\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.CreateApplication" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:ApplicationName ""
                                                                                                                    :ApplicationDescription ""
                                                                                                                    :RuntimeEnvironment ""
                                                                                                                    :ServiceExecutionRole ""
                                                                                                                    :ApplicationConfiguration ""
                                                                                                                    :CloudWatchLoggingOptions ""
                                                                                                                    :Tags ""
                                                                                                                    :ApplicationMode ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.CreateApplication"

	payload := strings.NewReader("{\n  \"ApplicationName\": \"\",\n  \"ApplicationDescription\": \"\",\n  \"RuntimeEnvironment\": \"\",\n  \"ServiceExecutionRole\": \"\",\n  \"ApplicationConfiguration\": \"\",\n  \"CloudWatchLoggingOptions\": \"\",\n  \"Tags\": \"\",\n  \"ApplicationMode\": \"\"\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: 224

{
  "ApplicationName": "",
  "ApplicationDescription": "",
  "RuntimeEnvironment": "",
  "ServiceExecutionRole": "",
  "ApplicationConfiguration": "",
  "CloudWatchLoggingOptions": "",
  "Tags": "",
  "ApplicationMode": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.CreateApplication")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ApplicationName\": \"\",\n  \"ApplicationDescription\": \"\",\n  \"RuntimeEnvironment\": \"\",\n  \"ServiceExecutionRole\": \"\",\n  \"ApplicationConfiguration\": \"\",\n  \"CloudWatchLoggingOptions\": \"\",\n  \"Tags\": \"\",\n  \"ApplicationMode\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.CreateApplication"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ApplicationName\": \"\",\n  \"ApplicationDescription\": \"\",\n  \"RuntimeEnvironment\": \"\",\n  \"ServiceExecutionRole\": \"\",\n  \"ApplicationConfiguration\": \"\",\n  \"CloudWatchLoggingOptions\": \"\",\n  \"Tags\": \"\",\n  \"ApplicationMode\": \"\"\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  \"ApplicationName\": \"\",\n  \"ApplicationDescription\": \"\",\n  \"RuntimeEnvironment\": \"\",\n  \"ServiceExecutionRole\": \"\",\n  \"ApplicationConfiguration\": \"\",\n  \"CloudWatchLoggingOptions\": \"\",\n  \"Tags\": \"\",\n  \"ApplicationMode\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.CreateApplication")
  .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=KinesisAnalytics_20180523.CreateApplication")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ApplicationName\": \"\",\n  \"ApplicationDescription\": \"\",\n  \"RuntimeEnvironment\": \"\",\n  \"ServiceExecutionRole\": \"\",\n  \"ApplicationConfiguration\": \"\",\n  \"CloudWatchLoggingOptions\": \"\",\n  \"Tags\": \"\",\n  \"ApplicationMode\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ApplicationName: '',
  ApplicationDescription: '',
  RuntimeEnvironment: '',
  ServiceExecutionRole: '',
  ApplicationConfiguration: '',
  CloudWatchLoggingOptions: '',
  Tags: '',
  ApplicationMode: ''
});

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=KinesisAnalytics_20180523.CreateApplication');
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=KinesisAnalytics_20180523.CreateApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ApplicationName: '',
    ApplicationDescription: '',
    RuntimeEnvironment: '',
    ServiceExecutionRole: '',
    ApplicationConfiguration: '',
    CloudWatchLoggingOptions: '',
    Tags: '',
    ApplicationMode: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.CreateApplication';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","ApplicationDescription":"","RuntimeEnvironment":"","ServiceExecutionRole":"","ApplicationConfiguration":"","CloudWatchLoggingOptions":"","Tags":"","ApplicationMode":""}'
};

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=KinesisAnalytics_20180523.CreateApplication',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ApplicationName": "",\n  "ApplicationDescription": "",\n  "RuntimeEnvironment": "",\n  "ServiceExecutionRole": "",\n  "ApplicationConfiguration": "",\n  "CloudWatchLoggingOptions": "",\n  "Tags": "",\n  "ApplicationMode": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ApplicationName\": \"\",\n  \"ApplicationDescription\": \"\",\n  \"RuntimeEnvironment\": \"\",\n  \"ServiceExecutionRole\": \"\",\n  \"ApplicationConfiguration\": \"\",\n  \"CloudWatchLoggingOptions\": \"\",\n  \"Tags\": \"\",\n  \"ApplicationMode\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.CreateApplication")
  .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({
  ApplicationName: '',
  ApplicationDescription: '',
  RuntimeEnvironment: '',
  ServiceExecutionRole: '',
  ApplicationConfiguration: '',
  CloudWatchLoggingOptions: '',
  Tags: '',
  ApplicationMode: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.CreateApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ApplicationName: '',
    ApplicationDescription: '',
    RuntimeEnvironment: '',
    ServiceExecutionRole: '',
    ApplicationConfiguration: '',
    CloudWatchLoggingOptions: '',
    Tags: '',
    ApplicationMode: ''
  },
  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=KinesisAnalytics_20180523.CreateApplication');

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

req.type('json');
req.send({
  ApplicationName: '',
  ApplicationDescription: '',
  RuntimeEnvironment: '',
  ServiceExecutionRole: '',
  ApplicationConfiguration: '',
  CloudWatchLoggingOptions: '',
  Tags: '',
  ApplicationMode: ''
});

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=KinesisAnalytics_20180523.CreateApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ApplicationName: '',
    ApplicationDescription: '',
    RuntimeEnvironment: '',
    ServiceExecutionRole: '',
    ApplicationConfiguration: '',
    CloudWatchLoggingOptions: '',
    Tags: '',
    ApplicationMode: ''
  }
};

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=KinesisAnalytics_20180523.CreateApplication';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","ApplicationDescription":"","RuntimeEnvironment":"","ServiceExecutionRole":"","ApplicationConfiguration":"","CloudWatchLoggingOptions":"","Tags":"","ApplicationMode":""}'
};

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 = @{ @"ApplicationName": @"",
                              @"ApplicationDescription": @"",
                              @"RuntimeEnvironment": @"",
                              @"ServiceExecutionRole": @"",
                              @"ApplicationConfiguration": @"",
                              @"CloudWatchLoggingOptions": @"",
                              @"Tags": @"",
                              @"ApplicationMode": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.CreateApplication"]
                                                       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=KinesisAnalytics_20180523.CreateApplication" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ApplicationName\": \"\",\n  \"ApplicationDescription\": \"\",\n  \"RuntimeEnvironment\": \"\",\n  \"ServiceExecutionRole\": \"\",\n  \"ApplicationConfiguration\": \"\",\n  \"CloudWatchLoggingOptions\": \"\",\n  \"Tags\": \"\",\n  \"ApplicationMode\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.CreateApplication",
  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([
    'ApplicationName' => '',
    'ApplicationDescription' => '',
    'RuntimeEnvironment' => '',
    'ServiceExecutionRole' => '',
    'ApplicationConfiguration' => '',
    'CloudWatchLoggingOptions' => '',
    'Tags' => '',
    'ApplicationMode' => ''
  ]),
  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=KinesisAnalytics_20180523.CreateApplication', [
  'body' => '{
  "ApplicationName": "",
  "ApplicationDescription": "",
  "RuntimeEnvironment": "",
  "ServiceExecutionRole": "",
  "ApplicationConfiguration": "",
  "CloudWatchLoggingOptions": "",
  "Tags": "",
  "ApplicationMode": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ApplicationName' => '',
  'ApplicationDescription' => '',
  'RuntimeEnvironment' => '',
  'ServiceExecutionRole' => '',
  'ApplicationConfiguration' => '',
  'CloudWatchLoggingOptions' => '',
  'Tags' => '',
  'ApplicationMode' => ''
]));

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

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

append(json_encode([
  'ApplicationName' => '',
  'ApplicationDescription' => '',
  'RuntimeEnvironment' => '',
  'ServiceExecutionRole' => '',
  'ApplicationConfiguration' => '',
  'CloudWatchLoggingOptions' => '',
  'Tags' => '',
  'ApplicationMode' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.CreateApplication');
$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=KinesisAnalytics_20180523.CreateApplication' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ApplicationName": "",
  "ApplicationDescription": "",
  "RuntimeEnvironment": "",
  "ServiceExecutionRole": "",
  "ApplicationConfiguration": "",
  "CloudWatchLoggingOptions": "",
  "Tags": "",
  "ApplicationMode": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.CreateApplication' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ApplicationName": "",
  "ApplicationDescription": "",
  "RuntimeEnvironment": "",
  "ServiceExecutionRole": "",
  "ApplicationConfiguration": "",
  "CloudWatchLoggingOptions": "",
  "Tags": "",
  "ApplicationMode": ""
}'

import http.client

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

payload = "{\n  \"ApplicationName\": \"\",\n  \"ApplicationDescription\": \"\",\n  \"RuntimeEnvironment\": \"\",\n  \"ServiceExecutionRole\": \"\",\n  \"ApplicationConfiguration\": \"\",\n  \"CloudWatchLoggingOptions\": \"\",\n  \"Tags\": \"\",\n  \"ApplicationMode\": \"\"\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=KinesisAnalytics_20180523.CreateApplication"

payload = {
    "ApplicationName": "",
    "ApplicationDescription": "",
    "RuntimeEnvironment": "",
    "ServiceExecutionRole": "",
    "ApplicationConfiguration": "",
    "CloudWatchLoggingOptions": "",
    "Tags": "",
    "ApplicationMode": ""
}
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=KinesisAnalytics_20180523.CreateApplication"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"ApplicationDescription\": \"\",\n  \"RuntimeEnvironment\": \"\",\n  \"ServiceExecutionRole\": \"\",\n  \"ApplicationConfiguration\": \"\",\n  \"CloudWatchLoggingOptions\": \"\",\n  \"Tags\": \"\",\n  \"ApplicationMode\": \"\"\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=KinesisAnalytics_20180523.CreateApplication")

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  \"ApplicationName\": \"\",\n  \"ApplicationDescription\": \"\",\n  \"RuntimeEnvironment\": \"\",\n  \"ServiceExecutionRole\": \"\",\n  \"ApplicationConfiguration\": \"\",\n  \"CloudWatchLoggingOptions\": \"\",\n  \"Tags\": \"\",\n  \"ApplicationMode\": \"\"\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  \"ApplicationName\": \"\",\n  \"ApplicationDescription\": \"\",\n  \"RuntimeEnvironment\": \"\",\n  \"ServiceExecutionRole\": \"\",\n  \"ApplicationConfiguration\": \"\",\n  \"CloudWatchLoggingOptions\": \"\",\n  \"Tags\": \"\",\n  \"ApplicationMode\": \"\"\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=KinesisAnalytics_20180523.CreateApplication";

    let payload = json!({
        "ApplicationName": "",
        "ApplicationDescription": "",
        "RuntimeEnvironment": "",
        "ServiceExecutionRole": "",
        "ApplicationConfiguration": "",
        "CloudWatchLoggingOptions": "",
        "Tags": "",
        "ApplicationMode": ""
    });

    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=KinesisAnalytics_20180523.CreateApplication' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "ApplicationDescription": "",
  "RuntimeEnvironment": "",
  "ServiceExecutionRole": "",
  "ApplicationConfiguration": "",
  "CloudWatchLoggingOptions": "",
  "Tags": "",
  "ApplicationMode": ""
}'

echo '{
  "ApplicationName": "",
  "ApplicationDescription": "",
  "RuntimeEnvironment": "",
  "ServiceExecutionRole": "",
  "ApplicationConfiguration": "",
  "CloudWatchLoggingOptions": "",
  "Tags": "",
  "ApplicationMode": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.CreateApplication' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ApplicationName": "",\n  "ApplicationDescription": "",\n  "RuntimeEnvironment": "",\n  "ServiceExecutionRole": "",\n  "ApplicationConfiguration": "",\n  "CloudWatchLoggingOptions": "",\n  "Tags": "",\n  "ApplicationMode": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.CreateApplication'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ApplicationName": "",
  "ApplicationDescription": "",
  "RuntimeEnvironment": "",
  "ServiceExecutionRole": "",
  "ApplicationConfiguration": "",
  "CloudWatchLoggingOptions": "",
  "Tags": "",
  "ApplicationMode": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.CreateApplicationPresignedUrl

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "UrlType": "",
  "SessionExpirationDurationInSeconds": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"ApplicationName\": \"\",\n  \"UrlType\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.CreateApplicationPresignedUrl" {:headers {:x-amz-target ""}
                                                                                                                  :content-type :json
                                                                                                                  :form-params {:ApplicationName ""
                                                                                                                                :UrlType ""
                                                                                                                                :SessionExpirationDurationInSeconds ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.CreateApplicationPresignedUrl"

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

{
  "ApplicationName": "",
  "UrlType": "",
  "SessionExpirationDurationInSeconds": ""
}

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

client.close();

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

const data = JSON.stringify({
  ApplicationName: '',
  UrlType: '',
  SessionExpirationDurationInSeconds: ''
});

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=KinesisAnalytics_20180523.CreateApplicationPresignedUrl');
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=KinesisAnalytics_20180523.CreateApplicationPresignedUrl',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', UrlType: '', SessionExpirationDurationInSeconds: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.CreateApplicationPresignedUrl';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","UrlType":"","SessionExpirationDurationInSeconds":""}'
};

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  ApplicationName: '',
  UrlType: '',
  SessionExpirationDurationInSeconds: ''
});

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=KinesisAnalytics_20180523.CreateApplicationPresignedUrl',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', UrlType: '', SessionExpirationDurationInSeconds: ''}
};

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=KinesisAnalytics_20180523.CreateApplicationPresignedUrl';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","UrlType":"","SessionExpirationDurationInSeconds":""}'
};

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 = @{ @"ApplicationName": @"",
                              @"UrlType": @"",
                              @"SessionExpirationDurationInSeconds": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ApplicationName' => '',
  'UrlType' => '',
  'SessionExpirationDurationInSeconds' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"ApplicationName\": \"\",\n  \"UrlType\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\"\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=KinesisAnalytics_20180523.CreateApplicationPresignedUrl"

payload = {
    "ApplicationName": "",
    "UrlType": "",
    "SessionExpirationDurationInSeconds": ""
}
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=KinesisAnalytics_20180523.CreateApplicationPresignedUrl"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"UrlType\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\"\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=KinesisAnalytics_20180523.CreateApplicationPresignedUrl")

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  \"ApplicationName\": \"\",\n  \"UrlType\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\"\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  \"ApplicationName\": \"\",\n  \"UrlType\": \"\",\n  \"SessionExpirationDurationInSeconds\": \"\"\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=KinesisAnalytics_20180523.CreateApplicationPresignedUrl";

    let payload = json!({
        "ApplicationName": "",
        "UrlType": "",
        "SessionExpirationDurationInSeconds": ""
    });

    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=KinesisAnalytics_20180523.CreateApplicationPresignedUrl' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "UrlType": "",
  "SessionExpirationDurationInSeconds": ""
}'

echo '{
  "ApplicationName": "",
  "UrlType": "",
  "SessionExpirationDurationInSeconds": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.CreateApplicationPresignedUrl' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ApplicationName": "",\n  "UrlType": "",\n  "SessionExpirationDurationInSeconds": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.CreateApplicationPresignedUrl'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.CreateApplicationSnapshot

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "SnapshotName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.CreateApplicationSnapshot" {:headers {:x-amz-target ""}
                                                                                                              :content-type :json
                                                                                                              :form-params {:ApplicationName ""
                                                                                                                            :SnapshotName ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.CreateApplicationSnapshot"

	payload := strings.NewReader("{\n  \"ApplicationName\": \"\",\n  \"SnapshotName\": \"\"\n}")

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

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

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

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

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

}

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

{
  "ApplicationName": "",
  "SnapshotName": ""
}

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

client.close();

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

const data = JSON.stringify({
  ApplicationName: '',
  SnapshotName: ''
});

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=KinesisAnalytics_20180523.CreateApplicationSnapshot');
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=KinesisAnalytics_20180523.CreateApplicationSnapshot',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', SnapshotName: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  ApplicationName: '',
  SnapshotName: ''
});

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=KinesisAnalytics_20180523.CreateApplicationSnapshot',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', SnapshotName: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"ApplicationName\": \"\",\n  \"SnapshotName\": \"\"\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=KinesisAnalytics_20180523.CreateApplicationSnapshot"

payload = {
    "ApplicationName": "",
    "SnapshotName": ""
}
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=KinesisAnalytics_20180523.CreateApplicationSnapshot"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"SnapshotName\": \"\"\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=KinesisAnalytics_20180523.CreateApplicationSnapshot")

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  \"ApplicationName\": \"\",\n  \"SnapshotName\": \"\"\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  \"ApplicationName\": \"\",\n  \"SnapshotName\": \"\"\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=KinesisAnalytics_20180523.CreateApplicationSnapshot";

    let payload = json!({
        "ApplicationName": "",
        "SnapshotName": ""
    });

    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=KinesisAnalytics_20180523.CreateApplicationSnapshot' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "SnapshotName": ""
}'

echo '{
  "ApplicationName": "",
  "SnapshotName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.CreateApplicationSnapshot' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplication

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "CreateTimestamp": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplication" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:ApplicationName ""
                                                                                                                    :CreateTimestamp ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplication"

	payload := strings.NewReader("{\n  \"ApplicationName\": \"\",\n  \"CreateTimestamp\": \"\"\n}")

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

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

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

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

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

}

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

{
  "ApplicationName": "",
  "CreateTimestamp": ""
}

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

client.close();

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

const data = JSON.stringify({
  ApplicationName: '',
  CreateTimestamp: ''
});

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=KinesisAnalytics_20180523.DeleteApplication');
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=KinesisAnalytics_20180523.DeleteApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', CreateTimestamp: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  ApplicationName: '',
  CreateTimestamp: ''
});

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=KinesisAnalytics_20180523.DeleteApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', CreateTimestamp: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"ApplicationName\": \"\",\n  \"CreateTimestamp\": \"\"\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=KinesisAnalytics_20180523.DeleteApplication"

payload = {
    "ApplicationName": "",
    "CreateTimestamp": ""
}
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=KinesisAnalytics_20180523.DeleteApplication"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"CreateTimestamp\": \"\"\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=KinesisAnalytics_20180523.DeleteApplication")

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  \"ApplicationName\": \"\",\n  \"CreateTimestamp\": \"\"\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  \"ApplicationName\": \"\",\n  \"CreateTimestamp\": \"\"\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=KinesisAnalytics_20180523.DeleteApplication";

    let payload = json!({
        "ApplicationName": "",
        "CreateTimestamp": ""
    });

    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=KinesisAnalytics_20180523.DeleteApplication' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "CreateTimestamp": ""
}'

echo '{
  "ApplicationName": "",
  "CreateTimestamp": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplication' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationCloudWatchLoggingOption

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "CloudWatchLoggingOptionId": "",
  "ConditionalToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"CloudWatchLoggingOptionId\": \"\",\n  \"ConditionalToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationCloudWatchLoggingOption" {:headers {:x-amz-target ""}
                                                                                                                             :content-type :json
                                                                                                                             :form-params {:ApplicationName ""
                                                                                                                                           :CurrentApplicationVersionId ""
                                                                                                                                           :CloudWatchLoggingOptionId ""
                                                                                                                                           :ConditionalToken ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationCloudWatchLoggingOption"

	payload := strings.NewReader("{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"CloudWatchLoggingOptionId\": \"\",\n  \"ConditionalToken\": \"\"\n}")

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

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

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

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

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

}

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

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "CloudWatchLoggingOptionId": "",
  "ConditionalToken": ""
}

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

client.close();

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

const data = JSON.stringify({
  ApplicationName: '',
  CurrentApplicationVersionId: '',
  CloudWatchLoggingOptionId: '',
  ConditionalToken: ''
});

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=KinesisAnalytics_20180523.DeleteApplicationCloudWatchLoggingOption');
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=KinesisAnalytics_20180523.DeleteApplicationCloudWatchLoggingOption',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ApplicationName: '',
    CurrentApplicationVersionId: '',
    CloudWatchLoggingOptionId: '',
    ConditionalToken: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationCloudWatchLoggingOption';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","CurrentApplicationVersionId":"","CloudWatchLoggingOptionId":"","ConditionalToken":""}'
};

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=KinesisAnalytics_20180523.DeleteApplicationCloudWatchLoggingOption',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ApplicationName": "",\n  "CurrentApplicationVersionId": "",\n  "CloudWatchLoggingOptionId": "",\n  "ConditionalToken": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  ApplicationName: '',
  CurrentApplicationVersionId: '',
  CloudWatchLoggingOptionId: '',
  ConditionalToken: ''
});

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=KinesisAnalytics_20180523.DeleteApplicationCloudWatchLoggingOption',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ApplicationName: '',
    CurrentApplicationVersionId: '',
    CloudWatchLoggingOptionId: '',
    ConditionalToken: ''
  }
};

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=KinesisAnalytics_20180523.DeleteApplicationCloudWatchLoggingOption';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","CurrentApplicationVersionId":"","CloudWatchLoggingOptionId":"","ConditionalToken":""}'
};

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 = @{ @"ApplicationName": @"",
                              @"CurrentApplicationVersionId": @"",
                              @"CloudWatchLoggingOptionId": @"",
                              @"ConditionalToken": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ApplicationName' => '',
  'CurrentApplicationVersionId' => '',
  'CloudWatchLoggingOptionId' => '',
  'ConditionalToken' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"CloudWatchLoggingOptionId\": \"\",\n  \"ConditionalToken\": \"\"\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=KinesisAnalytics_20180523.DeleteApplicationCloudWatchLoggingOption"

payload = {
    "ApplicationName": "",
    "CurrentApplicationVersionId": "",
    "CloudWatchLoggingOptionId": "",
    "ConditionalToken": ""
}
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=KinesisAnalytics_20180523.DeleteApplicationCloudWatchLoggingOption"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"CloudWatchLoggingOptionId\": \"\",\n  \"ConditionalToken\": \"\"\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=KinesisAnalytics_20180523.DeleteApplicationCloudWatchLoggingOption")

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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"CloudWatchLoggingOptionId\": \"\",\n  \"ConditionalToken\": \"\"\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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"CloudWatchLoggingOptionId\": \"\",\n  \"ConditionalToken\": \"\"\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=KinesisAnalytics_20180523.DeleteApplicationCloudWatchLoggingOption";

    let payload = json!({
        "ApplicationName": "",
        "CurrentApplicationVersionId": "",
        "CloudWatchLoggingOptionId": "",
        "ConditionalToken": ""
    });

    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=KinesisAnalytics_20180523.DeleteApplicationCloudWatchLoggingOption' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "CloudWatchLoggingOptionId": "",
  "ConditionalToken": ""
}'

echo '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "CloudWatchLoggingOptionId": "",
  "ConditionalToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationCloudWatchLoggingOption' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ApplicationName": "",\n  "CurrentApplicationVersionId": "",\n  "CloudWatchLoggingOptionId": "",\n  "ConditionalToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationCloudWatchLoggingOption'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationInputProcessingConfiguration

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "InputId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"InputId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationInputProcessingConfiguration" {:headers {:x-amz-target ""}
                                                                                                                                  :content-type :json
                                                                                                                                  :form-params {:ApplicationName ""
                                                                                                                                                :CurrentApplicationVersionId ""
                                                                                                                                                :InputId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationInputProcessingConfiguration"

	payload := strings.NewReader("{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"InputId\": \"\"\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: 81

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "InputId": ""
}

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

client.close();

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

const data = JSON.stringify({
  ApplicationName: '',
  CurrentApplicationVersionId: '',
  InputId: ''
});

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=KinesisAnalytics_20180523.DeleteApplicationInputProcessingConfiguration');
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=KinesisAnalytics_20180523.DeleteApplicationInputProcessingConfiguration',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', CurrentApplicationVersionId: '', InputId: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationInputProcessingConfiguration';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","CurrentApplicationVersionId":"","InputId":""}'
};

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  ApplicationName: '',
  CurrentApplicationVersionId: '',
  InputId: ''
});

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=KinesisAnalytics_20180523.DeleteApplicationInputProcessingConfiguration',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', CurrentApplicationVersionId: '', InputId: ''}
};

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=KinesisAnalytics_20180523.DeleteApplicationInputProcessingConfiguration';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","CurrentApplicationVersionId":"","InputId":""}'
};

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 = @{ @"ApplicationName": @"",
                              @"CurrentApplicationVersionId": @"",
                              @"InputId": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ApplicationName' => '',
  'CurrentApplicationVersionId' => '',
  'InputId' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"InputId\": \"\"\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=KinesisAnalytics_20180523.DeleteApplicationInputProcessingConfiguration"

payload = {
    "ApplicationName": "",
    "CurrentApplicationVersionId": "",
    "InputId": ""
}
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=KinesisAnalytics_20180523.DeleteApplicationInputProcessingConfiguration"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"InputId\": \"\"\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=KinesisAnalytics_20180523.DeleteApplicationInputProcessingConfiguration")

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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"InputId\": \"\"\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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"InputId\": \"\"\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=KinesisAnalytics_20180523.DeleteApplicationInputProcessingConfiguration";

    let payload = json!({
        "ApplicationName": "",
        "CurrentApplicationVersionId": "",
        "InputId": ""
    });

    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=KinesisAnalytics_20180523.DeleteApplicationInputProcessingConfiguration' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "InputId": ""
}'

echo '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "InputId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationInputProcessingConfiguration' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ApplicationName": "",\n  "CurrentApplicationVersionId": "",\n  "InputId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationInputProcessingConfiguration'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationOutput

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "OutputId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"OutputId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationOutput" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:ApplicationName ""
                                                                                                                          :CurrentApplicationVersionId ""
                                                                                                                          :OutputId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationOutput"

	payload := strings.NewReader("{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"OutputId\": \"\"\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: 82

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "OutputId": ""
}

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

client.close();

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

const data = JSON.stringify({
  ApplicationName: '',
  CurrentApplicationVersionId: '',
  OutputId: ''
});

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=KinesisAnalytics_20180523.DeleteApplicationOutput');
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=KinesisAnalytics_20180523.DeleteApplicationOutput',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', CurrentApplicationVersionId: '', OutputId: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationOutput';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","CurrentApplicationVersionId":"","OutputId":""}'
};

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  ApplicationName: '',
  CurrentApplicationVersionId: '',
  OutputId: ''
});

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=KinesisAnalytics_20180523.DeleteApplicationOutput',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', CurrentApplicationVersionId: '', OutputId: ''}
};

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=KinesisAnalytics_20180523.DeleteApplicationOutput';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","CurrentApplicationVersionId":"","OutputId":""}'
};

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 = @{ @"ApplicationName": @"",
                              @"CurrentApplicationVersionId": @"",
                              @"OutputId": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ApplicationName' => '',
  'CurrentApplicationVersionId' => '',
  'OutputId' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"OutputId\": \"\"\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=KinesisAnalytics_20180523.DeleteApplicationOutput"

payload = {
    "ApplicationName": "",
    "CurrentApplicationVersionId": "",
    "OutputId": ""
}
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=KinesisAnalytics_20180523.DeleteApplicationOutput"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"OutputId\": \"\"\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=KinesisAnalytics_20180523.DeleteApplicationOutput")

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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"OutputId\": \"\"\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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"OutputId\": \"\"\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=KinesisAnalytics_20180523.DeleteApplicationOutput";

    let payload = json!({
        "ApplicationName": "",
        "CurrentApplicationVersionId": "",
        "OutputId": ""
    });

    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=KinesisAnalytics_20180523.DeleteApplicationOutput' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "OutputId": ""
}'

echo '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "OutputId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationOutput' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ApplicationName": "",\n  "CurrentApplicationVersionId": "",\n  "OutputId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationOutput'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationReferenceDataSource

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "ReferenceId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ReferenceId\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationReferenceDataSource" {:headers {:x-amz-target ""}
                                                                                                                         :content-type :json
                                                                                                                         :form-params {:ApplicationName ""
                                                                                                                                       :CurrentApplicationVersionId ""
                                                                                                                                       :ReferenceId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationReferenceDataSource"

	payload := strings.NewReader("{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ReferenceId\": \"\"\n}")

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

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

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

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

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

}

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

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "ReferenceId": ""
}

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

client.close();

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

const data = JSON.stringify({
  ApplicationName: '',
  CurrentApplicationVersionId: '',
  ReferenceId: ''
});

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=KinesisAnalytics_20180523.DeleteApplicationReferenceDataSource');
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=KinesisAnalytics_20180523.DeleteApplicationReferenceDataSource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', CurrentApplicationVersionId: '', ReferenceId: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationReferenceDataSource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","CurrentApplicationVersionId":"","ReferenceId":""}'
};

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  ApplicationName: '',
  CurrentApplicationVersionId: '',
  ReferenceId: ''
});

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=KinesisAnalytics_20180523.DeleteApplicationReferenceDataSource',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', CurrentApplicationVersionId: '', ReferenceId: ''}
};

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=KinesisAnalytics_20180523.DeleteApplicationReferenceDataSource';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","CurrentApplicationVersionId":"","ReferenceId":""}'
};

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 = @{ @"ApplicationName": @"",
                              @"CurrentApplicationVersionId": @"",
                              @"ReferenceId": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ApplicationName' => '',
  'CurrentApplicationVersionId' => '',
  'ReferenceId' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ReferenceId\": \"\"\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=KinesisAnalytics_20180523.DeleteApplicationReferenceDataSource"

payload = {
    "ApplicationName": "",
    "CurrentApplicationVersionId": "",
    "ReferenceId": ""
}
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=KinesisAnalytics_20180523.DeleteApplicationReferenceDataSource"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ReferenceId\": \"\"\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=KinesisAnalytics_20180523.DeleteApplicationReferenceDataSource")

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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ReferenceId\": \"\"\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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ReferenceId\": \"\"\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=KinesisAnalytics_20180523.DeleteApplicationReferenceDataSource";

    let payload = json!({
        "ApplicationName": "",
        "CurrentApplicationVersionId": "",
        "ReferenceId": ""
    });

    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=KinesisAnalytics_20180523.DeleteApplicationReferenceDataSource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "ReferenceId": ""
}'

echo '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "ReferenceId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationReferenceDataSource' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ApplicationName": "",\n  "CurrentApplicationVersionId": "",\n  "ReferenceId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationReferenceDataSource'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationSnapshot

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "SnapshotName": "",
  "SnapshotCreationTimestamp": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"ApplicationName\": \"\",\n  \"SnapshotName\": \"\",\n  \"SnapshotCreationTimestamp\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationSnapshot" {:headers {:x-amz-target ""}
                                                                                                              :content-type :json
                                                                                                              :form-params {:ApplicationName ""
                                                                                                                            :SnapshotName ""
                                                                                                                            :SnapshotCreationTimestamp ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationSnapshot"

	payload := strings.NewReader("{\n  \"ApplicationName\": \"\",\n  \"SnapshotName\": \"\",\n  \"SnapshotCreationTimestamp\": \"\"\n}")

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

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

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

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

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

}

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

{
  "ApplicationName": "",
  "SnapshotName": "",
  "SnapshotCreationTimestamp": ""
}

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

client.close();

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

const data = JSON.stringify({
  ApplicationName: '',
  SnapshotName: '',
  SnapshotCreationTimestamp: ''
});

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=KinesisAnalytics_20180523.DeleteApplicationSnapshot');
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=KinesisAnalytics_20180523.DeleteApplicationSnapshot',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', SnapshotName: '', SnapshotCreationTimestamp: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationSnapshot';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","SnapshotName":"","SnapshotCreationTimestamp":""}'
};

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  ApplicationName: '',
  SnapshotName: '',
  SnapshotCreationTimestamp: ''
});

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=KinesisAnalytics_20180523.DeleteApplicationSnapshot',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', SnapshotName: '', SnapshotCreationTimestamp: ''}
};

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=KinesisAnalytics_20180523.DeleteApplicationSnapshot';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","SnapshotName":"","SnapshotCreationTimestamp":""}'
};

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 = @{ @"ApplicationName": @"",
                              @"SnapshotName": @"",
                              @"SnapshotCreationTimestamp": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ApplicationName' => '',
  'SnapshotName' => '',
  'SnapshotCreationTimestamp' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"ApplicationName\": \"\",\n  \"SnapshotName\": \"\",\n  \"SnapshotCreationTimestamp\": \"\"\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=KinesisAnalytics_20180523.DeleteApplicationSnapshot"

payload = {
    "ApplicationName": "",
    "SnapshotName": "",
    "SnapshotCreationTimestamp": ""
}
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=KinesisAnalytics_20180523.DeleteApplicationSnapshot"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"SnapshotName\": \"\",\n  \"SnapshotCreationTimestamp\": \"\"\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=KinesisAnalytics_20180523.DeleteApplicationSnapshot")

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  \"ApplicationName\": \"\",\n  \"SnapshotName\": \"\",\n  \"SnapshotCreationTimestamp\": \"\"\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  \"ApplicationName\": \"\",\n  \"SnapshotName\": \"\",\n  \"SnapshotCreationTimestamp\": \"\"\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=KinesisAnalytics_20180523.DeleteApplicationSnapshot";

    let payload = json!({
        "ApplicationName": "",
        "SnapshotName": "",
        "SnapshotCreationTimestamp": ""
    });

    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=KinesisAnalytics_20180523.DeleteApplicationSnapshot' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "SnapshotName": "",
  "SnapshotCreationTimestamp": ""
}'

echo '{
  "ApplicationName": "",
  "SnapshotName": "",
  "SnapshotCreationTimestamp": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationSnapshot' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ApplicationName": "",\n  "SnapshotName": "",\n  "SnapshotCreationTimestamp": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationSnapshot'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationVpcConfiguration

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "VpcConfigurationId": "",
  "ConditionalToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"VpcConfigurationId\": \"\",\n  \"ConditionalToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationVpcConfiguration" {:headers {:x-amz-target ""}
                                                                                                                      :content-type :json
                                                                                                                      :form-params {:ApplicationName ""
                                                                                                                                    :CurrentApplicationVersionId ""
                                                                                                                                    :VpcConfigurationId ""
                                                                                                                                    :ConditionalToken ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationVpcConfiguration"

	payload := strings.NewReader("{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"VpcConfigurationId\": \"\",\n  \"ConditionalToken\": \"\"\n}")

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

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

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

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

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

}

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

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "VpcConfigurationId": "",
  "ConditionalToken": ""
}

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

client.close();

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

const data = JSON.stringify({
  ApplicationName: '',
  CurrentApplicationVersionId: '',
  VpcConfigurationId: '',
  ConditionalToken: ''
});

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=KinesisAnalytics_20180523.DeleteApplicationVpcConfiguration');
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=KinesisAnalytics_20180523.DeleteApplicationVpcConfiguration',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ApplicationName: '',
    CurrentApplicationVersionId: '',
    VpcConfigurationId: '',
    ConditionalToken: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationVpcConfiguration';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","CurrentApplicationVersionId":"","VpcConfigurationId":"","ConditionalToken":""}'
};

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=KinesisAnalytics_20180523.DeleteApplicationVpcConfiguration',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ApplicationName": "",\n  "CurrentApplicationVersionId": "",\n  "VpcConfigurationId": "",\n  "ConditionalToken": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  ApplicationName: '',
  CurrentApplicationVersionId: '',
  VpcConfigurationId: '',
  ConditionalToken: ''
});

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=KinesisAnalytics_20180523.DeleteApplicationVpcConfiguration',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ApplicationName: '',
    CurrentApplicationVersionId: '',
    VpcConfigurationId: '',
    ConditionalToken: ''
  }
};

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=KinesisAnalytics_20180523.DeleteApplicationVpcConfiguration';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","CurrentApplicationVersionId":"","VpcConfigurationId":"","ConditionalToken":""}'
};

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 = @{ @"ApplicationName": @"",
                              @"CurrentApplicationVersionId": @"",
                              @"VpcConfigurationId": @"",
                              @"ConditionalToken": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ApplicationName' => '',
  'CurrentApplicationVersionId' => '',
  'VpcConfigurationId' => '',
  'ConditionalToken' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"VpcConfigurationId\": \"\",\n  \"ConditionalToken\": \"\"\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=KinesisAnalytics_20180523.DeleteApplicationVpcConfiguration"

payload = {
    "ApplicationName": "",
    "CurrentApplicationVersionId": "",
    "VpcConfigurationId": "",
    "ConditionalToken": ""
}
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=KinesisAnalytics_20180523.DeleteApplicationVpcConfiguration"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"VpcConfigurationId\": \"\",\n  \"ConditionalToken\": \"\"\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=KinesisAnalytics_20180523.DeleteApplicationVpcConfiguration")

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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"VpcConfigurationId\": \"\",\n  \"ConditionalToken\": \"\"\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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"VpcConfigurationId\": \"\",\n  \"ConditionalToken\": \"\"\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=KinesisAnalytics_20180523.DeleteApplicationVpcConfiguration";

    let payload = json!({
        "ApplicationName": "",
        "CurrentApplicationVersionId": "",
        "VpcConfigurationId": "",
        "ConditionalToken": ""
    });

    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=KinesisAnalytics_20180523.DeleteApplicationVpcConfiguration' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "VpcConfigurationId": "",
  "ConditionalToken": ""
}'

echo '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "VpcConfigurationId": "",
  "ConditionalToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationVpcConfiguration' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ApplicationName": "",\n  "CurrentApplicationVersionId": "",\n  "VpcConfigurationId": "",\n  "ConditionalToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DeleteApplicationVpcConfiguration'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DescribeApplication

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "IncludeAdditionalDetails": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DescribeApplication" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:ApplicationName ""
                                                                                                                      :IncludeAdditionalDetails ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DescribeApplication"

	payload := strings.NewReader("{\n  \"ApplicationName\": \"\",\n  \"IncludeAdditionalDetails\": \"\"\n}")

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

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

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

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

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

}

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

{
  "ApplicationName": "",
  "IncludeAdditionalDetails": ""
}

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

client.close();

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

const data = JSON.stringify({
  ApplicationName: '',
  IncludeAdditionalDetails: ''
});

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=KinesisAnalytics_20180523.DescribeApplication');
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=KinesisAnalytics_20180523.DescribeApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', IncludeAdditionalDetails: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  ApplicationName: '',
  IncludeAdditionalDetails: ''
});

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=KinesisAnalytics_20180523.DescribeApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', IncludeAdditionalDetails: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"ApplicationName\": \"\",\n  \"IncludeAdditionalDetails\": \"\"\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=KinesisAnalytics_20180523.DescribeApplication"

payload = {
    "ApplicationName": "",
    "IncludeAdditionalDetails": ""
}
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=KinesisAnalytics_20180523.DescribeApplication"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"IncludeAdditionalDetails\": \"\"\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=KinesisAnalytics_20180523.DescribeApplication")

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  \"ApplicationName\": \"\",\n  \"IncludeAdditionalDetails\": \"\"\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  \"ApplicationName\": \"\",\n  \"IncludeAdditionalDetails\": \"\"\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=KinesisAnalytics_20180523.DescribeApplication";

    let payload = json!({
        "ApplicationName": "",
        "IncludeAdditionalDetails": ""
    });

    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=KinesisAnalytics_20180523.DescribeApplication' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "IncludeAdditionalDetails": ""
}'

echo '{
  "ApplicationName": "",
  "IncludeAdditionalDetails": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DescribeApplication' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DescribeApplicationSnapshot

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "SnapshotName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DescribeApplicationSnapshot" {:headers {:x-amz-target ""}
                                                                                                                :content-type :json
                                                                                                                :form-params {:ApplicationName ""
                                                                                                                              :SnapshotName ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DescribeApplicationSnapshot"

	payload := strings.NewReader("{\n  \"ApplicationName\": \"\",\n  \"SnapshotName\": \"\"\n}")

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

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

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

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

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

}

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

{
  "ApplicationName": "",
  "SnapshotName": ""
}

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

client.close();

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

const data = JSON.stringify({
  ApplicationName: '',
  SnapshotName: ''
});

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=KinesisAnalytics_20180523.DescribeApplicationSnapshot');
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=KinesisAnalytics_20180523.DescribeApplicationSnapshot',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', SnapshotName: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  ApplicationName: '',
  SnapshotName: ''
});

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=KinesisAnalytics_20180523.DescribeApplicationSnapshot',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', SnapshotName: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"ApplicationName\": \"\",\n  \"SnapshotName\": \"\"\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=KinesisAnalytics_20180523.DescribeApplicationSnapshot"

payload = {
    "ApplicationName": "",
    "SnapshotName": ""
}
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=KinesisAnalytics_20180523.DescribeApplicationSnapshot"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"SnapshotName\": \"\"\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=KinesisAnalytics_20180523.DescribeApplicationSnapshot")

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  \"ApplicationName\": \"\",\n  \"SnapshotName\": \"\"\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  \"ApplicationName\": \"\",\n  \"SnapshotName\": \"\"\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=KinesisAnalytics_20180523.DescribeApplicationSnapshot";

    let payload = json!({
        "ApplicationName": "",
        "SnapshotName": ""
    });

    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=KinesisAnalytics_20180523.DescribeApplicationSnapshot' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "SnapshotName": ""
}'

echo '{
  "ApplicationName": "",
  "SnapshotName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DescribeApplicationSnapshot' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DescribeApplicationVersion

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "ApplicationVersionId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DescribeApplicationVersion" {:headers {:x-amz-target ""}
                                                                                                               :content-type :json
                                                                                                               :form-params {:ApplicationName ""
                                                                                                                             :ApplicationVersionId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DescribeApplicationVersion"

	payload := strings.NewReader("{\n  \"ApplicationName\": \"\",\n  \"ApplicationVersionId\": \"\"\n}")

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

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

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

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

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

}

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

{
  "ApplicationName": "",
  "ApplicationVersionId": ""
}

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

client.close();

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

const data = JSON.stringify({
  ApplicationName: '',
  ApplicationVersionId: ''
});

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=KinesisAnalytics_20180523.DescribeApplicationVersion');
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=KinesisAnalytics_20180523.DescribeApplicationVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', ApplicationVersionId: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  ApplicationName: '',
  ApplicationVersionId: ''
});

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=KinesisAnalytics_20180523.DescribeApplicationVersion',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', ApplicationVersionId: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"ApplicationName\": \"\",\n  \"ApplicationVersionId\": \"\"\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=KinesisAnalytics_20180523.DescribeApplicationVersion"

payload = {
    "ApplicationName": "",
    "ApplicationVersionId": ""
}
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=KinesisAnalytics_20180523.DescribeApplicationVersion"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"ApplicationVersionId\": \"\"\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=KinesisAnalytics_20180523.DescribeApplicationVersion")

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  \"ApplicationName\": \"\",\n  \"ApplicationVersionId\": \"\"\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  \"ApplicationName\": \"\",\n  \"ApplicationVersionId\": \"\"\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=KinesisAnalytics_20180523.DescribeApplicationVersion";

    let payload = json!({
        "ApplicationName": "",
        "ApplicationVersionId": ""
    });

    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=KinesisAnalytics_20180523.DescribeApplicationVersion' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "ApplicationVersionId": ""
}'

echo '{
  "ApplicationName": "",
  "ApplicationVersionId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DescribeApplicationVersion' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DiscoverInputSchema

HEADERS

X-Amz-Target

BODY json

{
  "ResourceARN": "",
  "ServiceExecutionRole": "",
  "InputStartingPositionConfiguration": "",
  "S3Configuration": "",
  "InputProcessingConfiguration": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"ServiceExecutionRole\": \"\",\n  \"InputStartingPositionConfiguration\": \"\",\n  \"S3Configuration\": \"\",\n  \"InputProcessingConfiguration\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DiscoverInputSchema" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:ResourceARN ""
                                                                                                                      :ServiceExecutionRole ""
                                                                                                                      :InputStartingPositionConfiguration ""
                                                                                                                      :S3Configuration ""
                                                                                                                      :InputProcessingConfiguration ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DiscoverInputSchema"

	payload := strings.NewReader("{\n  \"ResourceARN\": \"\",\n  \"ServiceExecutionRole\": \"\",\n  \"InputStartingPositionConfiguration\": \"\",\n  \"S3Configuration\": \"\",\n  \"InputProcessingConfiguration\": \"\"\n}")

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

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

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

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

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

}

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

{
  "ResourceARN": "",
  "ServiceExecutionRole": "",
  "InputStartingPositionConfiguration": "",
  "S3Configuration": "",
  "InputProcessingConfiguration": ""
}

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

client.close();

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

const data = JSON.stringify({
  ResourceARN: '',
  ServiceExecutionRole: '',
  InputStartingPositionConfiguration: '',
  S3Configuration: '',
  InputProcessingConfiguration: ''
});

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=KinesisAnalytics_20180523.DiscoverInputSchema');
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=KinesisAnalytics_20180523.DiscoverInputSchema',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ResourceARN: '',
    ServiceExecutionRole: '',
    InputStartingPositionConfiguration: '',
    S3Configuration: '',
    InputProcessingConfiguration: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DiscoverInputSchema';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceARN":"","ServiceExecutionRole":"","InputStartingPositionConfiguration":"","S3Configuration":"","InputProcessingConfiguration":""}'
};

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=KinesisAnalytics_20180523.DiscoverInputSchema',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResourceARN": "",\n  "ServiceExecutionRole": "",\n  "InputStartingPositionConfiguration": "",\n  "S3Configuration": "",\n  "InputProcessingConfiguration": ""\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  \"ServiceExecutionRole\": \"\",\n  \"InputStartingPositionConfiguration\": \"\",\n  \"S3Configuration\": \"\",\n  \"InputProcessingConfiguration\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DiscoverInputSchema")
  .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: '',
  ServiceExecutionRole: '',
  InputStartingPositionConfiguration: '',
  S3Configuration: '',
  InputProcessingConfiguration: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DiscoverInputSchema',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ResourceARN: '',
    ServiceExecutionRole: '',
    InputStartingPositionConfiguration: '',
    S3Configuration: '',
    InputProcessingConfiguration: ''
  },
  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=KinesisAnalytics_20180523.DiscoverInputSchema');

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

req.type('json');
req.send({
  ResourceARN: '',
  ServiceExecutionRole: '',
  InputStartingPositionConfiguration: '',
  S3Configuration: '',
  InputProcessingConfiguration: ''
});

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=KinesisAnalytics_20180523.DiscoverInputSchema',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ResourceARN: '',
    ServiceExecutionRole: '',
    InputStartingPositionConfiguration: '',
    S3Configuration: '',
    InputProcessingConfiguration: ''
  }
};

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=KinesisAnalytics_20180523.DiscoverInputSchema';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceARN":"","ServiceExecutionRole":"","InputStartingPositionConfiguration":"","S3Configuration":"","InputProcessingConfiguration":""}'
};

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": @"",
                              @"ServiceExecutionRole": @"",
                              @"InputStartingPositionConfiguration": @"",
                              @"S3Configuration": @"",
                              @"InputProcessingConfiguration": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DiscoverInputSchema"]
                                                       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=KinesisAnalytics_20180523.DiscoverInputSchema" 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  \"ServiceExecutionRole\": \"\",\n  \"InputStartingPositionConfiguration\": \"\",\n  \"S3Configuration\": \"\",\n  \"InputProcessingConfiguration\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DiscoverInputSchema",
  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' => '',
    'ServiceExecutionRole' => '',
    'InputStartingPositionConfiguration' => '',
    'S3Configuration' => '',
    'InputProcessingConfiguration' => ''
  ]),
  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=KinesisAnalytics_20180523.DiscoverInputSchema', [
  'body' => '{
  "ResourceARN": "",
  "ServiceExecutionRole": "",
  "InputStartingPositionConfiguration": "",
  "S3Configuration": "",
  "InputProcessingConfiguration": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ResourceARN' => '',
  'ServiceExecutionRole' => '',
  'InputStartingPositionConfiguration' => '',
  'S3Configuration' => '',
  'InputProcessingConfiguration' => ''
]));

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

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

append(json_encode([
  'ResourceARN' => '',
  'ServiceExecutionRole' => '',
  'InputStartingPositionConfiguration' => '',
  'S3Configuration' => '',
  'InputProcessingConfiguration' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DiscoverInputSchema');
$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=KinesisAnalytics_20180523.DiscoverInputSchema' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceARN": "",
  "ServiceExecutionRole": "",
  "InputStartingPositionConfiguration": "",
  "S3Configuration": "",
  "InputProcessingConfiguration": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DiscoverInputSchema' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceARN": "",
  "ServiceExecutionRole": "",
  "InputStartingPositionConfiguration": "",
  "S3Configuration": "",
  "InputProcessingConfiguration": ""
}'

import http.client

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

payload = "{\n  \"ResourceARN\": \"\",\n  \"ServiceExecutionRole\": \"\",\n  \"InputStartingPositionConfiguration\": \"\",\n  \"S3Configuration\": \"\",\n  \"InputProcessingConfiguration\": \"\"\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=KinesisAnalytics_20180523.DiscoverInputSchema"

payload = {
    "ResourceARN": "",
    "ServiceExecutionRole": "",
    "InputStartingPositionConfiguration": "",
    "S3Configuration": "",
    "InputProcessingConfiguration": ""
}
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=KinesisAnalytics_20180523.DiscoverInputSchema"

payload <- "{\n  \"ResourceARN\": \"\",\n  \"ServiceExecutionRole\": \"\",\n  \"InputStartingPositionConfiguration\": \"\",\n  \"S3Configuration\": \"\",\n  \"InputProcessingConfiguration\": \"\"\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=KinesisAnalytics_20180523.DiscoverInputSchema")

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  \"ServiceExecutionRole\": \"\",\n  \"InputStartingPositionConfiguration\": \"\",\n  \"S3Configuration\": \"\",\n  \"InputProcessingConfiguration\": \"\"\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  \"ServiceExecutionRole\": \"\",\n  \"InputStartingPositionConfiguration\": \"\",\n  \"S3Configuration\": \"\",\n  \"InputProcessingConfiguration\": \"\"\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=KinesisAnalytics_20180523.DiscoverInputSchema";

    let payload = json!({
        "ResourceARN": "",
        "ServiceExecutionRole": "",
        "InputStartingPositionConfiguration": "",
        "S3Configuration": "",
        "InputProcessingConfiguration": ""
    });

    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=KinesisAnalytics_20180523.DiscoverInputSchema' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceARN": "",
  "ServiceExecutionRole": "",
  "InputStartingPositionConfiguration": "",
  "S3Configuration": "",
  "InputProcessingConfiguration": ""
}'

echo '{
  "ResourceARN": "",
  "ServiceExecutionRole": "",
  "InputStartingPositionConfiguration": "",
  "S3Configuration": "",
  "InputProcessingConfiguration": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DiscoverInputSchema' \
  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  "ServiceExecutionRole": "",\n  "InputStartingPositionConfiguration": "",\n  "S3Configuration": "",\n  "InputProcessingConfiguration": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.DiscoverInputSchema'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ResourceARN": "",
  "ServiceExecutionRole": "",
  "InputStartingPositionConfiguration": "",
  "S3Configuration": "",
  "InputProcessingConfiguration": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationSnapshots

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "Limit": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"ApplicationName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationSnapshots" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:ApplicationName ""
                                                                                                                           :Limit ""
                                                                                                                           :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationSnapshots"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ApplicationName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationSnapshots"

	payload := strings.NewReader("{\n  \"ApplicationName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}")

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

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

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

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

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

}

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

{
  "ApplicationName": "",
  "Limit": "",
  "NextToken": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ApplicationName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationSnapshots")
  .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=KinesisAnalytics_20180523.ListApplicationSnapshots")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ApplicationName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ApplicationName: '',
  Limit: '',
  NextToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationSnapshots');
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=KinesisAnalytics_20180523.ListApplicationSnapshots',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', Limit: '', NextToken: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationSnapshots';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","Limit":"","NextToken":""}'
};

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

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

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationSnapshots',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ApplicationName: '', Limit: '', NextToken: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  ApplicationName: '',
  Limit: '',
  NextToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationSnapshots',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', Limit: '', NextToken: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationSnapshots';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","Limit":"","NextToken":""}'
};

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

#import 

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationSnapshots",
  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([
    'ApplicationName' => '',
    'Limit' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationSnapshots', [
  'body' => '{
  "ApplicationName": "",
  "Limit": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ApplicationName' => '',
  'Limit' => '',
  'NextToken' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"ApplicationName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationSnapshots"

payload = {
    "ApplicationName": "",
    "Limit": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationSnapshots"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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  \"ApplicationName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "ApplicationName": "",
        "Limit": "",
        "NextToken": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationSnapshots' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "Limit": "",
  "NextToken": ""
}'

echo '{
  "ApplicationName": "",
  "Limit": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationSnapshots' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ApplicationName": "",\n  "Limit": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationSnapshots'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationVersions

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "Limit": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"ApplicationName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationVersions" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:ApplicationName ""
                                                                                                                          :Limit ""
                                                                                                                          :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationVersions"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ApplicationName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationVersions"

	payload := strings.NewReader("{\n  \"ApplicationName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}")

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

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

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

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

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

}

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

{
  "ApplicationName": "",
  "Limit": "",
  "NextToken": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"ApplicationName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationVersions")
  .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=KinesisAnalytics_20180523.ListApplicationVersions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ApplicationName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ApplicationName: '',
  Limit: '',
  NextToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationVersions');
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=KinesisAnalytics_20180523.ListApplicationVersions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', Limit: '', NextToken: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationVersions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","Limit":"","NextToken":""}'
};

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

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

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationVersions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ApplicationName: '', Limit: '', NextToken: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  ApplicationName: '',
  Limit: '',
  NextToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationVersions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', Limit: '', NextToken: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationVersions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","Limit":"","NextToken":""}'
};

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

#import 

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationVersions",
  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([
    'ApplicationName' => '',
    'Limit' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationVersions', [
  'body' => '{
  "ApplicationName": "",
  "Limit": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ApplicationName' => '',
  'Limit' => '',
  'NextToken' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"ApplicationName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationVersions"

payload = {
    "ApplicationName": "",
    "Limit": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationVersions"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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  \"ApplicationName\": \"\",\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "ApplicationName": "",
        "Limit": "",
        "NextToken": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationVersions' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "Limit": "",
  "NextToken": ""
}'

echo '{
  "ApplicationName": "",
  "Limit": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationVersions' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ApplicationName": "",\n  "Limit": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplicationVersions'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplications

HEADERS

X-Amz-Target

BODY json

{
  "Limit": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplications" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:Limit ""
                                                                                                                   :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplications"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplications"

	payload := strings.NewReader("{\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}")

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

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

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

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

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

}

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

{
  "Limit": "",
  "NextToken": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

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

const data = JSON.stringify({
  Limit: '',
  NextToken: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplications');
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=KinesisAnalytics_20180523.ListApplications',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Limit: '', NextToken: ''}
};

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplications',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {Limit: '', NextToken: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  Limit: '',
  NextToken: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplications',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Limit: '', NextToken: ''}
};

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

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

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

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

#import 

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplications",
  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([
    'Limit' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplications"

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

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplications"

payload <- "{\n  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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  \"Limit\": \"\",\n  \"NextToken\": \"\"\n}"

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "Limit": "",
        "NextToken": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplications' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Limit": "",
  "NextToken": ""
}'

echo '{
  "Limit": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplications' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.ListApplications")! 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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.ListTagsForResource" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:ResourceARN ""}})

require "http/client"

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

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.ListTagsForResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceARN": ""
}'

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

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.RollbackApplication

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.RollbackApplication" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:ApplicationName ""
                                                                                                                      :CurrentApplicationVersionId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.RollbackApplication"

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

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": ""
}

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

client.close();

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

const data = JSON.stringify({
  ApplicationName: '',
  CurrentApplicationVersionId: ''
});

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=KinesisAnalytics_20180523.RollbackApplication');
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=KinesisAnalytics_20180523.RollbackApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', CurrentApplicationVersionId: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  ApplicationName: '',
  CurrentApplicationVersionId: ''
});

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=KinesisAnalytics_20180523.RollbackApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', CurrentApplicationVersionId: ''}
};

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

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

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

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

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.RollbackApplication');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ApplicationName' => '',
  'CurrentApplicationVersionId' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ApplicationName' => '',
  'CurrentApplicationVersionId' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.RollbackApplication');
$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=KinesisAnalytics_20180523.RollbackApplication' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.RollbackApplication' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\"\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=KinesisAnalytics_20180523.RollbackApplication"

payload = {
    "ApplicationName": "",
    "CurrentApplicationVersionId": ""
}
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=KinesisAnalytics_20180523.RollbackApplication"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\"\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=KinesisAnalytics_20180523.RollbackApplication")

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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\"\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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\"\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=KinesisAnalytics_20180523.RollbackApplication";

    let payload = json!({
        "ApplicationName": "",
        "CurrentApplicationVersionId": ""
    });

    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=KinesisAnalytics_20180523.RollbackApplication' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": ""
}'

echo '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.RollbackApplication' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ApplicationName": "",\n  "CurrentApplicationVersionId": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.RollbackApplication'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ApplicationName": "",
  "CurrentApplicationVersionId": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.RollbackApplication")! 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 StartApplication

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StartApplication

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "RunConfiguration": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StartApplication");

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  \"ApplicationName\": \"\",\n  \"RunConfiguration\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StartApplication" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:ApplicationName ""
                                                                                                                   :RunConfiguration ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StartApplication"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ApplicationName\": \"\",\n  \"RunConfiguration\": \"\"\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=KinesisAnalytics_20180523.StartApplication"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ApplicationName\": \"\",\n  \"RunConfiguration\": \"\"\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=KinesisAnalytics_20180523.StartApplication");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ApplicationName\": \"\",\n  \"RunConfiguration\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StartApplication"

	payload := strings.NewReader("{\n  \"ApplicationName\": \"\",\n  \"RunConfiguration\": \"\"\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

{
  "ApplicationName": "",
  "RunConfiguration": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StartApplication")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ApplicationName\": \"\",\n  \"RunConfiguration\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StartApplication"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ApplicationName\": \"\",\n  \"RunConfiguration\": \"\"\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  \"ApplicationName\": \"\",\n  \"RunConfiguration\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StartApplication")
  .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=KinesisAnalytics_20180523.StartApplication")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ApplicationName\": \"\",\n  \"RunConfiguration\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ApplicationName: '',
  RunConfiguration: ''
});

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=KinesisAnalytics_20180523.StartApplication');
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=KinesisAnalytics_20180523.StartApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', RunConfiguration: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StartApplication';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","RunConfiguration":""}'
};

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=KinesisAnalytics_20180523.StartApplication',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ApplicationName": "",\n  "RunConfiguration": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ApplicationName\": \"\",\n  \"RunConfiguration\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StartApplication")
  .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({ApplicationName: '', RunConfiguration: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StartApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ApplicationName: '', RunConfiguration: ''},
  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=KinesisAnalytics_20180523.StartApplication');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ApplicationName: '',
  RunConfiguration: ''
});

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=KinesisAnalytics_20180523.StartApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', RunConfiguration: ''}
};

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=KinesisAnalytics_20180523.StartApplication';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","RunConfiguration":""}'
};

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 = @{ @"ApplicationName": @"",
                              @"RunConfiguration": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StartApplication"]
                                                       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=KinesisAnalytics_20180523.StartApplication" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ApplicationName\": \"\",\n  \"RunConfiguration\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StartApplication",
  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([
    'ApplicationName' => '',
    'RunConfiguration' => ''
  ]),
  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=KinesisAnalytics_20180523.StartApplication', [
  'body' => '{
  "ApplicationName": "",
  "RunConfiguration": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StartApplication');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ApplicationName' => '',
  'RunConfiguration' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ApplicationName' => '',
  'RunConfiguration' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StartApplication');
$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=KinesisAnalytics_20180523.StartApplication' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ApplicationName": "",
  "RunConfiguration": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StartApplication' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ApplicationName": "",
  "RunConfiguration": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ApplicationName\": \"\",\n  \"RunConfiguration\": \"\"\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=KinesisAnalytics_20180523.StartApplication"

payload = {
    "ApplicationName": "",
    "RunConfiguration": ""
}
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=KinesisAnalytics_20180523.StartApplication"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"RunConfiguration\": \"\"\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=KinesisAnalytics_20180523.StartApplication")

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  \"ApplicationName\": \"\",\n  \"RunConfiguration\": \"\"\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  \"ApplicationName\": \"\",\n  \"RunConfiguration\": \"\"\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=KinesisAnalytics_20180523.StartApplication";

    let payload = json!({
        "ApplicationName": "",
        "RunConfiguration": ""
    });

    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=KinesisAnalytics_20180523.StartApplication' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "RunConfiguration": ""
}'

echo '{
  "ApplicationName": "",
  "RunConfiguration": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StartApplication' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ApplicationName": "",\n  "RunConfiguration": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StartApplication'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ApplicationName": "",
  "RunConfiguration": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StartApplication")! 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 StopApplication

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StopApplication

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "Force": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StopApplication");

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  \"ApplicationName\": \"\",\n  \"Force\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StopApplication" {:headers {:x-amz-target ""}
                                                                                                    :content-type :json
                                                                                                    :form-params {:ApplicationName ""
                                                                                                                  :Force ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StopApplication"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ApplicationName\": \"\",\n  \"Force\": \"\"\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=KinesisAnalytics_20180523.StopApplication"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ApplicationName\": \"\",\n  \"Force\": \"\"\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=KinesisAnalytics_20180523.StopApplication");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ApplicationName\": \"\",\n  \"Force\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StopApplication"

	payload := strings.NewReader("{\n  \"ApplicationName\": \"\",\n  \"Force\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 42

{
  "ApplicationName": "",
  "Force": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StopApplication")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ApplicationName\": \"\",\n  \"Force\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StopApplication"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ApplicationName\": \"\",\n  \"Force\": \"\"\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  \"ApplicationName\": \"\",\n  \"Force\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StopApplication")
  .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=KinesisAnalytics_20180523.StopApplication")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ApplicationName\": \"\",\n  \"Force\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ApplicationName: '',
  Force: ''
});

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=KinesisAnalytics_20180523.StopApplication');
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=KinesisAnalytics_20180523.StopApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', Force: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StopApplication';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","Force":""}'
};

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=KinesisAnalytics_20180523.StopApplication',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ApplicationName": "",\n  "Force": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ApplicationName\": \"\",\n  \"Force\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StopApplication")
  .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({ApplicationName: '', Force: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StopApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ApplicationName: '', Force: ''},
  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=KinesisAnalytics_20180523.StopApplication');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ApplicationName: '',
  Force: ''
});

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=KinesisAnalytics_20180523.StopApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', Force: ''}
};

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=KinesisAnalytics_20180523.StopApplication';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","Force":""}'
};

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 = @{ @"ApplicationName": @"",
                              @"Force": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StopApplication"]
                                                       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=KinesisAnalytics_20180523.StopApplication" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ApplicationName\": \"\",\n  \"Force\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StopApplication",
  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([
    'ApplicationName' => '',
    'Force' => ''
  ]),
  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=KinesisAnalytics_20180523.StopApplication', [
  'body' => '{
  "ApplicationName": "",
  "Force": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StopApplication');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ApplicationName' => '',
  'Force' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ApplicationName' => '',
  'Force' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StopApplication');
$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=KinesisAnalytics_20180523.StopApplication' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ApplicationName": "",
  "Force": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StopApplication' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ApplicationName": "",
  "Force": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ApplicationName\": \"\",\n  \"Force\": \"\"\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=KinesisAnalytics_20180523.StopApplication"

payload = {
    "ApplicationName": "",
    "Force": ""
}
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=KinesisAnalytics_20180523.StopApplication"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"Force\": \"\"\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=KinesisAnalytics_20180523.StopApplication")

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  \"ApplicationName\": \"\",\n  \"Force\": \"\"\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  \"ApplicationName\": \"\",\n  \"Force\": \"\"\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=KinesisAnalytics_20180523.StopApplication";

    let payload = json!({
        "ApplicationName": "",
        "Force": ""
    });

    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=KinesisAnalytics_20180523.StopApplication' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "Force": ""
}'

echo '{
  "ApplicationName": "",
  "Force": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StopApplication' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ApplicationName": "",\n  "Force": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StopApplication'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ApplicationName": "",
  "Force": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.StopApplication")! 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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.TagResource" {:headers {:x-amz-target ""}
                                                                                                :content-type :json
                                                                                                :form-params {:ResourceARN ""
                                                                                                              :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.TagResource', [
  'body' => '{
  "ResourceARN": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.TagResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceARN": "",
  "Tags": ""
}'

echo '{
  "ResourceARN": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.TagResource")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UntagResource

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.UntagResource" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:ResourceARN ""
                                                                                                                :TagKeys ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.UntagResource', [
  'body' => '{
  "ResourceARN": "",
  "TagKeys": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.UntagResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceARN": "",
  "TagKeys": ""
}'

echo '{
  "ResourceARN": "",
  "TagKeys": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.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=KinesisAnalytics_20180523.UntagResource")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()

POST UpdateApplication

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplication

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "ApplicationConfigurationUpdate": "",
  "ServiceExecutionRoleUpdate": "",
  "RunConfigurationUpdate": "",
  "CloudWatchLoggingOptionUpdates": "",
  "ConditionalToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplication");

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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ApplicationConfigurationUpdate\": \"\",\n  \"ServiceExecutionRoleUpdate\": \"\",\n  \"RunConfigurationUpdate\": \"\",\n  \"CloudWatchLoggingOptionUpdates\": \"\",\n  \"ConditionalToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplication" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:ApplicationName ""
                                                                                                                    :CurrentApplicationVersionId ""
                                                                                                                    :ApplicationConfigurationUpdate ""
                                                                                                                    :ServiceExecutionRoleUpdate ""
                                                                                                                    :RunConfigurationUpdate ""
                                                                                                                    :CloudWatchLoggingOptionUpdates ""
                                                                                                                    :ConditionalToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplication"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ApplicationConfigurationUpdate\": \"\",\n  \"ServiceExecutionRoleUpdate\": \"\",\n  \"RunConfigurationUpdate\": \"\",\n  \"CloudWatchLoggingOptionUpdates\": \"\",\n  \"ConditionalToken\": \"\"\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=KinesisAnalytics_20180523.UpdateApplication"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ApplicationConfigurationUpdate\": \"\",\n  \"ServiceExecutionRoleUpdate\": \"\",\n  \"RunConfigurationUpdate\": \"\",\n  \"CloudWatchLoggingOptionUpdates\": \"\",\n  \"ConditionalToken\": \"\"\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=KinesisAnalytics_20180523.UpdateApplication");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ApplicationConfigurationUpdate\": \"\",\n  \"ServiceExecutionRoleUpdate\": \"\",\n  \"RunConfigurationUpdate\": \"\",\n  \"CloudWatchLoggingOptionUpdates\": \"\",\n  \"ConditionalToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplication"

	payload := strings.NewReader("{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ApplicationConfigurationUpdate\": \"\",\n  \"ServiceExecutionRoleUpdate\": \"\",\n  \"RunConfigurationUpdate\": \"\",\n  \"CloudWatchLoggingOptionUpdates\": \"\",\n  \"ConditionalToken\": \"\"\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: 238

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "ApplicationConfigurationUpdate": "",
  "ServiceExecutionRoleUpdate": "",
  "RunConfigurationUpdate": "",
  "CloudWatchLoggingOptionUpdates": "",
  "ConditionalToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplication")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ApplicationConfigurationUpdate\": \"\",\n  \"ServiceExecutionRoleUpdate\": \"\",\n  \"RunConfigurationUpdate\": \"\",\n  \"CloudWatchLoggingOptionUpdates\": \"\",\n  \"ConditionalToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplication"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ApplicationConfigurationUpdate\": \"\",\n  \"ServiceExecutionRoleUpdate\": \"\",\n  \"RunConfigurationUpdate\": \"\",\n  \"CloudWatchLoggingOptionUpdates\": \"\",\n  \"ConditionalToken\": \"\"\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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ApplicationConfigurationUpdate\": \"\",\n  \"ServiceExecutionRoleUpdate\": \"\",\n  \"RunConfigurationUpdate\": \"\",\n  \"CloudWatchLoggingOptionUpdates\": \"\",\n  \"ConditionalToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplication")
  .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=KinesisAnalytics_20180523.UpdateApplication")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ApplicationConfigurationUpdate\": \"\",\n  \"ServiceExecutionRoleUpdate\": \"\",\n  \"RunConfigurationUpdate\": \"\",\n  \"CloudWatchLoggingOptionUpdates\": \"\",\n  \"ConditionalToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ApplicationName: '',
  CurrentApplicationVersionId: '',
  ApplicationConfigurationUpdate: '',
  ServiceExecutionRoleUpdate: '',
  RunConfigurationUpdate: '',
  CloudWatchLoggingOptionUpdates: '',
  ConditionalToken: ''
});

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=KinesisAnalytics_20180523.UpdateApplication');
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=KinesisAnalytics_20180523.UpdateApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ApplicationName: '',
    CurrentApplicationVersionId: '',
    ApplicationConfigurationUpdate: '',
    ServiceExecutionRoleUpdate: '',
    RunConfigurationUpdate: '',
    CloudWatchLoggingOptionUpdates: '',
    ConditionalToken: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplication';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","CurrentApplicationVersionId":"","ApplicationConfigurationUpdate":"","ServiceExecutionRoleUpdate":"","RunConfigurationUpdate":"","CloudWatchLoggingOptionUpdates":"","ConditionalToken":""}'
};

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=KinesisAnalytics_20180523.UpdateApplication',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ApplicationName": "",\n  "CurrentApplicationVersionId": "",\n  "ApplicationConfigurationUpdate": "",\n  "ServiceExecutionRoleUpdate": "",\n  "RunConfigurationUpdate": "",\n  "CloudWatchLoggingOptionUpdates": "",\n  "ConditionalToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ApplicationConfigurationUpdate\": \"\",\n  \"ServiceExecutionRoleUpdate\": \"\",\n  \"RunConfigurationUpdate\": \"\",\n  \"CloudWatchLoggingOptionUpdates\": \"\",\n  \"ConditionalToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplication")
  .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({
  ApplicationName: '',
  CurrentApplicationVersionId: '',
  ApplicationConfigurationUpdate: '',
  ServiceExecutionRoleUpdate: '',
  RunConfigurationUpdate: '',
  CloudWatchLoggingOptionUpdates: '',
  ConditionalToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ApplicationName: '',
    CurrentApplicationVersionId: '',
    ApplicationConfigurationUpdate: '',
    ServiceExecutionRoleUpdate: '',
    RunConfigurationUpdate: '',
    CloudWatchLoggingOptionUpdates: '',
    ConditionalToken: ''
  },
  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=KinesisAnalytics_20180523.UpdateApplication');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ApplicationName: '',
  CurrentApplicationVersionId: '',
  ApplicationConfigurationUpdate: '',
  ServiceExecutionRoleUpdate: '',
  RunConfigurationUpdate: '',
  CloudWatchLoggingOptionUpdates: '',
  ConditionalToken: ''
});

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=KinesisAnalytics_20180523.UpdateApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ApplicationName: '',
    CurrentApplicationVersionId: '',
    ApplicationConfigurationUpdate: '',
    ServiceExecutionRoleUpdate: '',
    RunConfigurationUpdate: '',
    CloudWatchLoggingOptionUpdates: '',
    ConditionalToken: ''
  }
};

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=KinesisAnalytics_20180523.UpdateApplication';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","CurrentApplicationVersionId":"","ApplicationConfigurationUpdate":"","ServiceExecutionRoleUpdate":"","RunConfigurationUpdate":"","CloudWatchLoggingOptionUpdates":"","ConditionalToken":""}'
};

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 = @{ @"ApplicationName": @"",
                              @"CurrentApplicationVersionId": @"",
                              @"ApplicationConfigurationUpdate": @"",
                              @"ServiceExecutionRoleUpdate": @"",
                              @"RunConfigurationUpdate": @"",
                              @"CloudWatchLoggingOptionUpdates": @"",
                              @"ConditionalToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplication"]
                                                       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=KinesisAnalytics_20180523.UpdateApplication" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ApplicationConfigurationUpdate\": \"\",\n  \"ServiceExecutionRoleUpdate\": \"\",\n  \"RunConfigurationUpdate\": \"\",\n  \"CloudWatchLoggingOptionUpdates\": \"\",\n  \"ConditionalToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplication",
  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([
    'ApplicationName' => '',
    'CurrentApplicationVersionId' => '',
    'ApplicationConfigurationUpdate' => '',
    'ServiceExecutionRoleUpdate' => '',
    'RunConfigurationUpdate' => '',
    'CloudWatchLoggingOptionUpdates' => '',
    'ConditionalToken' => ''
  ]),
  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=KinesisAnalytics_20180523.UpdateApplication', [
  'body' => '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "ApplicationConfigurationUpdate": "",
  "ServiceExecutionRoleUpdate": "",
  "RunConfigurationUpdate": "",
  "CloudWatchLoggingOptionUpdates": "",
  "ConditionalToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplication');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ApplicationName' => '',
  'CurrentApplicationVersionId' => '',
  'ApplicationConfigurationUpdate' => '',
  'ServiceExecutionRoleUpdate' => '',
  'RunConfigurationUpdate' => '',
  'CloudWatchLoggingOptionUpdates' => '',
  'ConditionalToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ApplicationName' => '',
  'CurrentApplicationVersionId' => '',
  'ApplicationConfigurationUpdate' => '',
  'ServiceExecutionRoleUpdate' => '',
  'RunConfigurationUpdate' => '',
  'CloudWatchLoggingOptionUpdates' => '',
  'ConditionalToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplication');
$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=KinesisAnalytics_20180523.UpdateApplication' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "ApplicationConfigurationUpdate": "",
  "ServiceExecutionRoleUpdate": "",
  "RunConfigurationUpdate": "",
  "CloudWatchLoggingOptionUpdates": "",
  "ConditionalToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplication' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "ApplicationConfigurationUpdate": "",
  "ServiceExecutionRoleUpdate": "",
  "RunConfigurationUpdate": "",
  "CloudWatchLoggingOptionUpdates": "",
  "ConditionalToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ApplicationConfigurationUpdate\": \"\",\n  \"ServiceExecutionRoleUpdate\": \"\",\n  \"RunConfigurationUpdate\": \"\",\n  \"CloudWatchLoggingOptionUpdates\": \"\",\n  \"ConditionalToken\": \"\"\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=KinesisAnalytics_20180523.UpdateApplication"

payload = {
    "ApplicationName": "",
    "CurrentApplicationVersionId": "",
    "ApplicationConfigurationUpdate": "",
    "ServiceExecutionRoleUpdate": "",
    "RunConfigurationUpdate": "",
    "CloudWatchLoggingOptionUpdates": "",
    "ConditionalToken": ""
}
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=KinesisAnalytics_20180523.UpdateApplication"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ApplicationConfigurationUpdate\": \"\",\n  \"ServiceExecutionRoleUpdate\": \"\",\n  \"RunConfigurationUpdate\": \"\",\n  \"CloudWatchLoggingOptionUpdates\": \"\",\n  \"ConditionalToken\": \"\"\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=KinesisAnalytics_20180523.UpdateApplication")

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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ApplicationConfigurationUpdate\": \"\",\n  \"ServiceExecutionRoleUpdate\": \"\",\n  \"RunConfigurationUpdate\": \"\",\n  \"CloudWatchLoggingOptionUpdates\": \"\",\n  \"ConditionalToken\": \"\"\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  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ApplicationConfigurationUpdate\": \"\",\n  \"ServiceExecutionRoleUpdate\": \"\",\n  \"RunConfigurationUpdate\": \"\",\n  \"CloudWatchLoggingOptionUpdates\": \"\",\n  \"ConditionalToken\": \"\"\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=KinesisAnalytics_20180523.UpdateApplication";

    let payload = json!({
        "ApplicationName": "",
        "CurrentApplicationVersionId": "",
        "ApplicationConfigurationUpdate": "",
        "ServiceExecutionRoleUpdate": "",
        "RunConfigurationUpdate": "",
        "CloudWatchLoggingOptionUpdates": "",
        "ConditionalToken": ""
    });

    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=KinesisAnalytics_20180523.UpdateApplication' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "ApplicationConfigurationUpdate": "",
  "ServiceExecutionRoleUpdate": "",
  "RunConfigurationUpdate": "",
  "CloudWatchLoggingOptionUpdates": "",
  "ConditionalToken": ""
}'

echo '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "ApplicationConfigurationUpdate": "",
  "ServiceExecutionRoleUpdate": "",
  "RunConfigurationUpdate": "",
  "CloudWatchLoggingOptionUpdates": "",
  "ConditionalToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplication' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ApplicationName": "",\n  "CurrentApplicationVersionId": "",\n  "ApplicationConfigurationUpdate": "",\n  "ServiceExecutionRoleUpdate": "",\n  "RunConfigurationUpdate": "",\n  "CloudWatchLoggingOptionUpdates": "",\n  "ConditionalToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplication'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "ApplicationConfigurationUpdate": "",
  "ServiceExecutionRoleUpdate": "",
  "RunConfigurationUpdate": "",
  "CloudWatchLoggingOptionUpdates": "",
  "ConditionalToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplication")! 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 UpdateApplicationMaintenanceConfiguration

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "ApplicationMaintenanceConfigurationUpdate": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration");

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  \"ApplicationName\": \"\",\n  \"ApplicationMaintenanceConfigurationUpdate\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration" {:headers {:x-amz-target ""}
                                                                                                                              :content-type :json
                                                                                                                              :form-params {:ApplicationName ""
                                                                                                                                            :ApplicationMaintenanceConfigurationUpdate ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ApplicationName\": \"\",\n  \"ApplicationMaintenanceConfigurationUpdate\": \"\"\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=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ApplicationName\": \"\",\n  \"ApplicationMaintenanceConfigurationUpdate\": \"\"\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=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ApplicationName\": \"\",\n  \"ApplicationMaintenanceConfigurationUpdate\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration"

	payload := strings.NewReader("{\n  \"ApplicationName\": \"\",\n  \"ApplicationMaintenanceConfigurationUpdate\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 78

{
  "ApplicationName": "",
  "ApplicationMaintenanceConfigurationUpdate": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ApplicationName\": \"\",\n  \"ApplicationMaintenanceConfigurationUpdate\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ApplicationName\": \"\",\n  \"ApplicationMaintenanceConfigurationUpdate\": \"\"\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  \"ApplicationName\": \"\",\n  \"ApplicationMaintenanceConfigurationUpdate\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration")
  .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=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ApplicationName\": \"\",\n  \"ApplicationMaintenanceConfigurationUpdate\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ApplicationName: '',
  ApplicationMaintenanceConfigurationUpdate: ''
});

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=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration');
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=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', ApplicationMaintenanceConfigurationUpdate: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","ApplicationMaintenanceConfigurationUpdate":""}'
};

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=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ApplicationName": "",\n  "ApplicationMaintenanceConfigurationUpdate": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ApplicationName\": \"\",\n  \"ApplicationMaintenanceConfigurationUpdate\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration")
  .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({ApplicationName: '', ApplicationMaintenanceConfigurationUpdate: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {ApplicationName: '', ApplicationMaintenanceConfigurationUpdate: ''},
  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=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  ApplicationName: '',
  ApplicationMaintenanceConfigurationUpdate: ''
});

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=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', ApplicationMaintenanceConfigurationUpdate: ''}
};

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=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","ApplicationMaintenanceConfigurationUpdate":""}'
};

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 = @{ @"ApplicationName": @"",
                              @"ApplicationMaintenanceConfigurationUpdate": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration"]
                                                       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=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ApplicationName\": \"\",\n  \"ApplicationMaintenanceConfigurationUpdate\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration",
  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([
    'ApplicationName' => '',
    'ApplicationMaintenanceConfigurationUpdate' => ''
  ]),
  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=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration', [
  'body' => '{
  "ApplicationName": "",
  "ApplicationMaintenanceConfigurationUpdate": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ApplicationName' => '',
  'ApplicationMaintenanceConfigurationUpdate' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'ApplicationName' => '',
  'ApplicationMaintenanceConfigurationUpdate' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration');
$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=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ApplicationName": "",
  "ApplicationMaintenanceConfigurationUpdate": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ApplicationName": "",
  "ApplicationMaintenanceConfigurationUpdate": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"ApplicationName\": \"\",\n  \"ApplicationMaintenanceConfigurationUpdate\": \"\"\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=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration"

payload = {
    "ApplicationName": "",
    "ApplicationMaintenanceConfigurationUpdate": ""
}
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=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"ApplicationMaintenanceConfigurationUpdate\": \"\"\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=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration")

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  \"ApplicationName\": \"\",\n  \"ApplicationMaintenanceConfigurationUpdate\": \"\"\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  \"ApplicationName\": \"\",\n  \"ApplicationMaintenanceConfigurationUpdate\": \"\"\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=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration";

    let payload = json!({
        "ApplicationName": "",
        "ApplicationMaintenanceConfigurationUpdate": ""
    });

    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=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "ApplicationMaintenanceConfigurationUpdate": ""
}'

echo '{
  "ApplicationName": "",
  "ApplicationMaintenanceConfigurationUpdate": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ApplicationName": "",\n  "ApplicationMaintenanceConfigurationUpdate": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ApplicationName": "",
  "ApplicationMaintenanceConfigurationUpdate": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20180523.UpdateApplicationMaintenanceConfiguration")! 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()

Amazon Kinesis Analytics

Amazon Kinesis Analyticsv2018-05-23

Related APIs