Amazon Kinesis Analytics

POST AddApplicationCloudWatchLoggingOption

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

HEADERS

X-Amz-Target

BODY json

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

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_20150814.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}");

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

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

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

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

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

client.close();

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

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

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

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

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

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

const request = require('request');

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

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

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

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

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

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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}" in

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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' => ''
]));

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

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

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

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

import http.client

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

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

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

payload <- "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"CloudWatchLoggingOption\": \"\"\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_20150814.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}"

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}"
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_20150814.AddApplicationCloudWatchLoggingOption";

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

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

echo '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "CloudWatchLoggingOption": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.AddApplicationCloudWatchLoggingOption'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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_20150814.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_20150814.AddApplicationInput" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:ApplicationName ""
                                                                                                                      :CurrentApplicationVersionId ""
                                                                                                                      :Input ""}})

require "http/client"

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

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.AddApplicationInputProcessingConfiguration" {:headers {:x-amz-target ""}
                                                                                                                               :content-type :json
                                                                                                                               :form-params {:ApplicationName ""
                                                                                                                                             :CurrentApplicationVersionId ""
                                                                                                                                             :InputId ""
                                                                                                                                             :InputProcessingConfiguration ""}})

require "http/client"

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

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.AddApplicationOutput" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:ApplicationName ""
                                                                                                                       :CurrentApplicationVersionId ""
                                                                                                                       :Output ""}})

require "http/client"

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

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.AddApplicationReferenceDataSource" {:headers {:x-amz-target ""}
                                                                                                                      :content-type :json
                                                                                                                      :form-params {:ApplicationName ""
                                                                                                                                    :CurrentApplicationVersionId ""
                                                                                                                                    :ReferenceDataSource ""}})

require "http/client"

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

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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 CreateApplication

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

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "ApplicationDescription": "",
  "Inputs": "",
  "Outputs": "",
  "CloudWatchLoggingOptions": "",
  "ApplicationCode": "",
  "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_20150814.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  \"Inputs\": \"\",\n  \"Outputs\": \"\",\n  \"CloudWatchLoggingOptions\": \"\",\n  \"ApplicationCode\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.CreateApplication" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:ApplicationName ""
                                                                                                                    :ApplicationDescription ""
                                                                                                                    :Inputs ""
                                                                                                                    :Outputs ""
                                                                                                                    :CloudWatchLoggingOptions ""
                                                                                                                    :ApplicationCode ""
                                                                                                                    :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.CreateApplication"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ApplicationName\": \"\",\n  \"ApplicationDescription\": \"\",\n  \"Inputs\": \"\",\n  \"Outputs\": \"\",\n  \"CloudWatchLoggingOptions\": \"\",\n  \"ApplicationCode\": \"\",\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_20150814.CreateApplication"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ApplicationName\": \"\",\n  \"ApplicationDescription\": \"\",\n  \"Inputs\": \"\",\n  \"Outputs\": \"\",\n  \"CloudWatchLoggingOptions\": \"\",\n  \"ApplicationCode\": \"\",\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_20150814.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  \"Inputs\": \"\",\n  \"Outputs\": \"\",\n  \"CloudWatchLoggingOptions\": \"\",\n  \"ApplicationCode\": \"\",\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_20150814.CreateApplication"

	payload := strings.NewReader("{\n  \"ApplicationName\": \"\",\n  \"ApplicationDescription\": \"\",\n  \"Inputs\": \"\",\n  \"Outputs\": \"\",\n  \"CloudWatchLoggingOptions\": \"\",\n  \"ApplicationCode\": \"\",\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: 165

{
  "ApplicationName": "",
  "ApplicationDescription": "",
  "Inputs": "",
  "Outputs": "",
  "CloudWatchLoggingOptions": "",
  "ApplicationCode": "",
  "Tags": ""
}

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

client.close();

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

const data = JSON.stringify({
  ApplicationName: '',
  ApplicationDescription: '',
  Inputs: '',
  Outputs: '',
  CloudWatchLoggingOptions: '',
  ApplicationCode: '',
  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_20150814.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_20150814.CreateApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ApplicationName: '',
    ApplicationDescription: '',
    Inputs: '',
    Outputs: '',
    CloudWatchLoggingOptions: '',
    ApplicationCode: '',
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.CreateApplication';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","ApplicationDescription":"","Inputs":"","Outputs":"","CloudWatchLoggingOptions":"","ApplicationCode":"","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_20150814.CreateApplication',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ApplicationName": "",\n  "ApplicationDescription": "",\n  "Inputs": "",\n  "Outputs": "",\n  "CloudWatchLoggingOptions": "",\n  "ApplicationCode": "",\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  \"ApplicationName\": \"\",\n  \"ApplicationDescription\": \"\",\n  \"Inputs\": \"\",\n  \"Outputs\": \"\",\n  \"CloudWatchLoggingOptions\": \"\",\n  \"ApplicationCode\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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: '',
  Inputs: '',
  Outputs: '',
  CloudWatchLoggingOptions: '',
  ApplicationCode: '',
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.CreateApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ApplicationName: '',
    ApplicationDescription: '',
    Inputs: '',
    Outputs: '',
    CloudWatchLoggingOptions: '',
    ApplicationCode: '',
    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_20150814.CreateApplication');

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

req.type('json');
req.send({
  ApplicationName: '',
  ApplicationDescription: '',
  Inputs: '',
  Outputs: '',
  CloudWatchLoggingOptions: '',
  ApplicationCode: '',
  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_20150814.CreateApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ApplicationName: '',
    ApplicationDescription: '',
    Inputs: '',
    Outputs: '',
    CloudWatchLoggingOptions: '',
    ApplicationCode: '',
    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_20150814.CreateApplication';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ApplicationName":"","ApplicationDescription":"","Inputs":"","Outputs":"","CloudWatchLoggingOptions":"","ApplicationCode":"","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 = @{ @"ApplicationName": @"",
                              @"ApplicationDescription": @"",
                              @"Inputs": @"",
                              @"Outputs": @"",
                              @"CloudWatchLoggingOptions": @"",
                              @"ApplicationCode": @"",
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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  \"Inputs\": \"\",\n  \"Outputs\": \"\",\n  \"CloudWatchLoggingOptions\": \"\",\n  \"ApplicationCode\": \"\",\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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' => '',
    'Inputs' => '',
    'Outputs' => '',
    'CloudWatchLoggingOptions' => '',
    'ApplicationCode' => '',
    '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_20150814.CreateApplication', [
  'body' => '{
  "ApplicationName": "",
  "ApplicationDescription": "",
  "Inputs": "",
  "Outputs": "",
  "CloudWatchLoggingOptions": "",
  "ApplicationCode": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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' => '',
  'Inputs' => '',
  'Outputs' => '',
  'CloudWatchLoggingOptions' => '',
  'ApplicationCode' => '',
  'Tags' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"ApplicationName\": \"\",\n  \"ApplicationDescription\": \"\",\n  \"Inputs\": \"\",\n  \"Outputs\": \"\",\n  \"CloudWatchLoggingOptions\": \"\",\n  \"ApplicationCode\": \"\",\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_20150814.CreateApplication"

payload = {
    "ApplicationName": "",
    "ApplicationDescription": "",
    "Inputs": "",
    "Outputs": "",
    "CloudWatchLoggingOptions": "",
    "ApplicationCode": "",
    "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_20150814.CreateApplication"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"ApplicationDescription\": \"\",\n  \"Inputs\": \"\",\n  \"Outputs\": \"\",\n  \"CloudWatchLoggingOptions\": \"\",\n  \"ApplicationCode\": \"\",\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_20150814.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  \"Inputs\": \"\",\n  \"Outputs\": \"\",\n  \"CloudWatchLoggingOptions\": \"\",\n  \"ApplicationCode\": \"\",\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  \"ApplicationName\": \"\",\n  \"ApplicationDescription\": \"\",\n  \"Inputs\": \"\",\n  \"Outputs\": \"\",\n  \"CloudWatchLoggingOptions\": \"\",\n  \"ApplicationCode\": \"\",\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_20150814.CreateApplication";

    let payload = json!({
        "ApplicationName": "",
        "ApplicationDescription": "",
        "Inputs": "",
        "Outputs": "",
        "CloudWatchLoggingOptions": "",
        "ApplicationCode": "",
        "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_20150814.CreateApplication' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "ApplicationDescription": "",
  "Inputs": "",
  "Outputs": "",
  "CloudWatchLoggingOptions": "",
  "ApplicationCode": "",
  "Tags": ""
}'

echo '{
  "ApplicationName": "",
  "ApplicationDescription": "",
  "Inputs": "",
  "Outputs": "",
  "CloudWatchLoggingOptions": "",
  "ApplicationCode": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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  "Inputs": "",\n  "Outputs": "",\n  "CloudWatchLoggingOptions": "",\n  "ApplicationCode": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.CreateApplication'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ApplicationName": "",
  "ApplicationDescription": "",
  "Inputs": "",
  "Outputs": "",
  "CloudWatchLoggingOptions": "",
  "ApplicationCode": "",
  "Tags": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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_20150814.DeleteApplication" {:headers {:x-amz-target ""}
                                                                                                      :content-type :json
                                                                                                      :form-params {:ApplicationName ""
                                                                                                                    :CreateTimestamp ""}})

require "http/client"

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

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.DeleteApplication' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "CreateTimestamp": ""
}'

echo '{
  "ApplicationName": "",
  "CreateTimestamp": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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_20150814.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_20150814.DeleteApplicationCloudWatchLoggingOption

HEADERS

X-Amz-Target

BODY json

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

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_20150814.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}");

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

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

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

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

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

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

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

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

}

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

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

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

client.close();

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

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

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

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

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

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

const request = require('request');

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

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

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

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

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

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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}" in

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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' => ''
]));

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

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

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

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

import http.client

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

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

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

payload <- "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"CloudWatchLoggingOptionId\": \"\"\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_20150814.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}"

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}"
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_20150814.DeleteApplicationCloudWatchLoggingOption";

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

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

echo '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "CloudWatchLoggingOptionId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.DeleteApplicationCloudWatchLoggingOption'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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_20150814.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_20150814.DeleteApplicationInputProcessingConfiguration" {:headers {:x-amz-target ""}
                                                                                                                                  :content-type :json
                                                                                                                                  :form-params {:ApplicationName ""
                                                                                                                                                :CurrentApplicationVersionId ""
                                                                                                                                                :InputId ""}})

require "http/client"

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

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.DeleteApplicationOutput" {:headers {:x-amz-target ""}
                                                                                                            :content-type :json
                                                                                                            :form-params {:ApplicationName ""
                                                                                                                          :CurrentApplicationVersionId ""
                                                                                                                          :OutputId ""}})

require "http/client"

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

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.DeleteApplicationReferenceDataSource" {:headers {:x-amz-target ""}
                                                                                                                         :content-type :json
                                                                                                                         :form-params {:ApplicationName ""
                                                                                                                                       :CurrentApplicationVersionId ""
                                                                                                                                       :ReferenceId ""}})

require "http/client"

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

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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 DescribeApplication

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.DescribeApplication

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": ""
}

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_20150814.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}");

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.DescribeApplication"

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

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

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

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

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

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

}

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

{
  "ApplicationName": ""
}

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

client.close();

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

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

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

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

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

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

const request = require('request');

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

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

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

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

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

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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}" in

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"ApplicationName\": \"\"\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_20150814.DescribeApplication"

payload = { "ApplicationName": "" }
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_20150814.DescribeApplication"

payload <- "{\n  \"ApplicationName\": \"\"\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_20150814.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}"

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}"
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_20150814.DescribeApplication";

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

    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_20150814.DescribeApplication' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": ""
}'

echo '{
  "ApplicationName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.DescribeApplication'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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 DiscoverInputSchema

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.DiscoverInputSchema

HEADERS

X-Amz-Target

BODY json

{
  "ResourceARN": "",
  "RoleARN": "",
  "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_20150814.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  \"RoleARN\": \"\",\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_20150814.DiscoverInputSchema" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:ResourceARN ""
                                                                                                                      :RoleARN ""
                                                                                                                      :InputStartingPositionConfiguration ""
                                                                                                                      :S3Configuration ""
                                                                                                                      :InputProcessingConfiguration ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.DiscoverInputSchema"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ResourceARN\": \"\",\n  \"RoleARN\": \"\",\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_20150814.DiscoverInputSchema"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ResourceARN\": \"\",\n  \"RoleARN\": \"\",\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_20150814.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  \"RoleARN\": \"\",\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_20150814.DiscoverInputSchema"

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

{
  "ResourceARN": "",
  "RoleARN": "",
  "InputStartingPositionConfiguration": "",
  "S3Configuration": "",
  "InputProcessingConfiguration": ""
}

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

const data = JSON.stringify({
  ResourceARN: '',
  RoleARN: '',
  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_20150814.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_20150814.DiscoverInputSchema',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ResourceARN: '',
    RoleARN: '',
    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_20150814.DiscoverInputSchema';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceARN":"","RoleARN":"","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_20150814.DiscoverInputSchema',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ResourceARN": "",\n  "RoleARN": "",\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  \"RoleARN\": \"\",\n  \"InputStartingPositionConfiguration\": \"\",\n  \"S3Configuration\": \"\",\n  \"InputProcessingConfiguration\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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: '',
  RoleARN: '',
  InputStartingPositionConfiguration: '',
  S3Configuration: '',
  InputProcessingConfiguration: ''
}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  ResourceARN: '',
  RoleARN: '',
  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_20150814.DiscoverInputSchema',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ResourceARN: '',
    RoleARN: '',
    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_20150814.DiscoverInputSchema';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ResourceARN":"","RoleARN":"","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": @"",
                              @"RoleARN": @"",
                              @"InputStartingPositionConfiguration": @"",
                              @"S3Configuration": @"",
                              @"InputProcessingConfiguration": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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  \"RoleARN\": \"\",\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_20150814.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' => '',
    'RoleARN' => '',
    '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_20150814.DiscoverInputSchema', [
  'body' => '{
  "ResourceARN": "",
  "RoleARN": "",
  "InputStartingPositionConfiguration": "",
  "S3Configuration": "",
  "InputProcessingConfiguration": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ResourceARN' => '',
  'RoleARN' => '',
  'InputStartingPositionConfiguration' => '',
  'S3Configuration' => '',
  'InputProcessingConfiguration' => ''
]));

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

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

append(json_encode([
  'ResourceARN' => '',
  'RoleARN' => '',
  'InputStartingPositionConfiguration' => '',
  'S3Configuration' => '',
  'InputProcessingConfiguration' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.DiscoverInputSchema' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceARN": "",
  "RoleARN": "",
  "InputStartingPositionConfiguration": "",
  "S3Configuration": "",
  "InputProcessingConfiguration": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.DiscoverInputSchema' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ResourceARN": "",
  "RoleARN": "",
  "InputStartingPositionConfiguration": "",
  "S3Configuration": "",
  "InputProcessingConfiguration": ""
}'

import http.client

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

payload = "{\n  \"ResourceARN\": \"\",\n  \"RoleARN\": \"\",\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_20150814.DiscoverInputSchema"

payload = {
    "ResourceARN": "",
    "RoleARN": "",
    "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_20150814.DiscoverInputSchema"

payload <- "{\n  \"ResourceARN\": \"\",\n  \"RoleARN\": \"\",\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_20150814.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  \"RoleARN\": \"\",\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  \"RoleARN\": \"\",\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_20150814.DiscoverInputSchema";

    let payload = json!({
        "ResourceARN": "",
        "RoleARN": "",
        "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_20150814.DiscoverInputSchema' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceARN": "",
  "RoleARN": "",
  "InputStartingPositionConfiguration": "",
  "S3Configuration": "",
  "InputProcessingConfiguration": ""
}'

echo '{
  "ResourceARN": "",
  "RoleARN": "",
  "InputStartingPositionConfiguration": "",
  "S3Configuration": "",
  "InputProcessingConfiguration": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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  "RoleARN": "",\n  "InputStartingPositionConfiguration": "",\n  "S3Configuration": "",\n  "InputProcessingConfiguration": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.DiscoverInputSchema'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ResourceARN": "",
  "RoleARN": "",
  "InputStartingPositionConfiguration": "",
  "S3Configuration": "",
  "InputProcessingConfiguration": ""
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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 ListApplications

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.ListApplications

HEADERS

X-Amz-Target

BODY json

{
  "Limit": "",
  "ExclusiveStartApplicationName": ""
}

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_20150814.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  \"ExclusiveStartApplicationName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.ListApplications" {:headers {:x-amz-target ""}
                                                                                                     :content-type :json
                                                                                                     :form-params {:Limit ""
                                                                                                                   :ExclusiveStartApplicationName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.ListApplications"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"Limit\": \"\",\n  \"ExclusiveStartApplicationName\": \"\"\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_20150814.ListApplications"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"Limit\": \"\",\n  \"ExclusiveStartApplicationName\": \"\"\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_20150814.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  \"ExclusiveStartApplicationName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.ListApplications"

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

{
  "Limit": "",
  "ExclusiveStartApplicationName": ""
}

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

client.close();

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

const data = JSON.stringify({
  Limit: '',
  ExclusiveStartApplicationName: ''
});

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_20150814.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_20150814.ListApplications',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Limit: '', ExclusiveStartApplicationName: ''}
};

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

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

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_20150814.ListApplications',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "Limit": "",\n  "ExclusiveStartApplicationName": ""\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  \"ExclusiveStartApplicationName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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: '', ExclusiveStartApplicationName: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  Limit: '',
  ExclusiveStartApplicationName: ''
});

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_20150814.ListApplications',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {Limit: '', ExclusiveStartApplicationName: ''}
};

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

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": @"",
                              @"ExclusiveStartApplicationName": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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  \"ExclusiveStartApplicationName\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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' => '',
    'ExclusiveStartApplicationName' => ''
  ]),
  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_20150814.ListApplications', [
  'body' => '{
  "Limit": "",
  "ExclusiveStartApplicationName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"Limit\": \"\",\n  \"ExclusiveStartApplicationName\": \"\"\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_20150814.ListApplications"

payload = {
    "Limit": "",
    "ExclusiveStartApplicationName": ""
}
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_20150814.ListApplications"

payload <- "{\n  \"Limit\": \"\",\n  \"ExclusiveStartApplicationName\": \"\"\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_20150814.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  \"ExclusiveStartApplicationName\": \"\"\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  \"ExclusiveStartApplicationName\": \"\"\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_20150814.ListApplications";

    let payload = json!({
        "Limit": "",
        "ExclusiveStartApplicationName": ""
    });

    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_20150814.ListApplications' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "Limit": "",
  "ExclusiveStartApplicationName": ""
}'

echo '{
  "Limit": "",
  "ExclusiveStartApplicationName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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  "ExclusiveStartApplicationName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.ListApplications'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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_20150814.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_20150814.ListTagsForResource" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:ResourceARN ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.ListTagsForResource', [
  'body' => '{
  "ResourceARN": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.ListTagsForResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceARN": ""
}'

echo '{
  "ResourceARN": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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_20150814.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 StartApplication

{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.StartApplication

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "InputConfigurations": ""
}

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_20150814.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  \"InputConfigurations\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.StartApplication"

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

{
  "ApplicationName": "",
  "InputConfigurations": ""
}

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

client.close();

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

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

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_20150814.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_20150814.StartApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', InputConfigurations: ''}
};

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

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

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

const request = require('request');

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

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

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

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_20150814.StartApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', InputConfigurations: ''}
};

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

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": @"",
                              @"InputConfigurations": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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  \"InputConfigurations\": \"\"\n}" in

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"ApplicationName\": \"\",\n  \"InputConfigurations\": \"\"\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_20150814.StartApplication"

payload = {
    "ApplicationName": "",
    "InputConfigurations": ""
}
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_20150814.StartApplication"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"InputConfigurations\": \"\"\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_20150814.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  \"InputConfigurations\": \"\"\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  \"InputConfigurations\": \"\"\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_20150814.StartApplication";

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

    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_20150814.StartApplication' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": "",
  "InputConfigurations": ""
}'

echo '{
  "ApplicationName": "",
  "InputConfigurations": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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  "InputConfigurations": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.StartApplication'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.StopApplication

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": ""
}

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_20150814.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}");

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.StopApplication"

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

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

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

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

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

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

}

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

{
  "ApplicationName": ""
}

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

client.close();

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

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

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

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

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

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

const request = require('request');

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

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

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

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

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

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

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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}" in

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"ApplicationName\": \"\"\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_20150814.StopApplication"

payload = { "ApplicationName": "" }
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_20150814.StopApplication"

payload <- "{\n  \"ApplicationName\": \"\"\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_20150814.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}"

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}"
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_20150814.StopApplication";

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

    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_20150814.StopApplication' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ApplicationName": ""
}'

echo '{
  "ApplicationName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.StopApplication'

import Foundation

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

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

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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_20150814.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_20150814.TagResource" {:headers {:x-amz-target ""}
                                                                                                :content-type :json
                                                                                                :form-params {:ResourceARN ""
                                                                                                              :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.TagResource', [
  'body' => '{
  "ResourceARN": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.TagResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceARN": "",
  "Tags": ""
}'

echo '{
  "ResourceARN": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.UntagResource" {:headers {:x-amz-target ""}
                                                                                                  :content-type :json
                                                                                                  :form-params {:ResourceARN ""
                                                                                                                :TagKeys ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.UntagResource', [
  'body' => '{
  "ResourceARN": "",
  "TagKeys": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.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_20150814.UntagResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceARN": "",
  "TagKeys": ""
}'

echo '{
  "ResourceARN": "",
  "TagKeys": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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_20150814.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_20150814.UpdateApplication

HEADERS

X-Amz-Target

BODY json

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "ApplicationUpdate": ""
}

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_20150814.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  \"ApplicationUpdate\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.UpdateApplication"

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

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

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

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

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

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

}

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

{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "ApplicationUpdate": ""
}

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

client.close();

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

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

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_20150814.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_20150814.UpdateApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', CurrentApplicationVersionId: '', ApplicationUpdate: ''}
};

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

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

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

const request = require('request');

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

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

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

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_20150814.UpdateApplication',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {ApplicationName: '', CurrentApplicationVersionId: '', ApplicationUpdate: ''}
};

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

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": @"",
                              @"ApplicationUpdate": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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_20150814.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  \"ApplicationUpdate\": \"\"\n}" in

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

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

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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' => '',
  'ApplicationUpdate' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ApplicationUpdate\": \"\"\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_20150814.UpdateApplication"

payload = {
    "ApplicationName": "",
    "CurrentApplicationVersionId": "",
    "ApplicationUpdate": ""
}
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_20150814.UpdateApplication"

payload <- "{\n  \"ApplicationName\": \"\",\n  \"CurrentApplicationVersionId\": \"\",\n  \"ApplicationUpdate\": \"\"\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_20150814.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  \"ApplicationUpdate\": \"\"\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  \"ApplicationUpdate\": \"\"\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_20150814.UpdateApplication";

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

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

echo '{
  "ApplicationName": "",
  "CurrentApplicationVersionId": "",
  "ApplicationUpdate": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.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  "ApplicationUpdate": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=KinesisAnalytics_20150814.UpdateApplication'

import Foundation

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

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

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