Amazon Lookout for Equipment

POST CreateDataset

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateDataset

HEADERS

X-Amz-Target

BODY json

{
  "DatasetName": "",
  "DatasetSchema": "",
  "ServerSideKmsKeyId": "",
  "ClientToken": "",
  "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=AWSLookoutEquipmentFrontendService.CreateDataset");

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  \"DatasetName\": \"\",\n  \"DatasetSchema\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateDataset" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:DatasetName ""
                                                                                                                         :DatasetSchema ""
                                                                                                                         :ServerSideKmsKeyId ""
                                                                                                                         :ClientToken ""
                                                                                                                         :Tags ""}})

require "http/client"

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

	payload := strings.NewReader("{\n  \"DatasetName\": \"\",\n  \"DatasetSchema\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"ClientToken\": \"\",\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: 109

{
  "DatasetName": "",
  "DatasetSchema": "",
  "ServerSideKmsKeyId": "",
  "ClientToken": "",
  "Tags": ""
}

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

client.close();

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

const data = JSON.stringify({
  DatasetName: '',
  DatasetSchema: '',
  ServerSideKmsKeyId: '',
  ClientToken: '',
  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=AWSLookoutEquipmentFrontendService.CreateDataset');
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=AWSLookoutEquipmentFrontendService.CreateDataset',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    DatasetName: '',
    DatasetSchema: '',
    ServerSideKmsKeyId: '',
    ClientToken: '',
    Tags: ''
  }
};

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

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

const request = require('request');

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

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

req.type('json');
req.send({
  DatasetName: '',
  DatasetSchema: '',
  ServerSideKmsKeyId: '',
  ClientToken: '',
  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=AWSLookoutEquipmentFrontendService.CreateDataset',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    DatasetName: '',
    DatasetSchema: '',
    ServerSideKmsKeyId: '',
    ClientToken: '',
    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=AWSLookoutEquipmentFrontendService.CreateDataset';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DatasetName":"","DatasetSchema":"","ServerSideKmsKeyId":"","ClientToken":"","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 = @{ @"DatasetName": @"",
                              @"DatasetSchema": @"",
                              @"ServerSideKmsKeyId": @"",
                              @"ClientToken": @"",
                              @"Tags": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateDataset",
  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([
    'DatasetName' => '',
    'DatasetSchema' => '',
    'ServerSideKmsKeyId' => '',
    'ClientToken' => '',
    '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=AWSLookoutEquipmentFrontendService.CreateDataset', [
  'body' => '{
  "DatasetName": "",
  "DatasetSchema": "",
  "ServerSideKmsKeyId": "",
  "ClientToken": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DatasetName' => '',
  'DatasetSchema' => '',
  'ServerSideKmsKeyId' => '',
  'ClientToken' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'DatasetName' => '',
  'DatasetSchema' => '',
  'ServerSideKmsKeyId' => '',
  'ClientToken' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateDataset');
$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=AWSLookoutEquipmentFrontendService.CreateDataset' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DatasetName": "",
  "DatasetSchema": "",
  "ServerSideKmsKeyId": "",
  "ClientToken": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateDataset' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DatasetName": "",
  "DatasetSchema": "",
  "ServerSideKmsKeyId": "",
  "ClientToken": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"DatasetName\": \"\",\n  \"DatasetSchema\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"ClientToken\": \"\",\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=AWSLookoutEquipmentFrontendService.CreateDataset"

payload = {
    "DatasetName": "",
    "DatasetSchema": "",
    "ServerSideKmsKeyId": "",
    "ClientToken": "",
    "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=AWSLookoutEquipmentFrontendService.CreateDataset"

payload <- "{\n  \"DatasetName\": \"\",\n  \"DatasetSchema\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"ClientToken\": \"\",\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=AWSLookoutEquipmentFrontendService.CreateDataset")

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  \"DatasetName\": \"\",\n  \"DatasetSchema\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"ClientToken\": \"\",\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  \"DatasetName\": \"\",\n  \"DatasetSchema\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"ClientToken\": \"\",\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=AWSLookoutEquipmentFrontendService.CreateDataset";

    let payload = json!({
        "DatasetName": "",
        "DatasetSchema": "",
        "ServerSideKmsKeyId": "",
        "ClientToken": "",
        "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=AWSLookoutEquipmentFrontendService.CreateDataset' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "DatasetName": "",
  "DatasetSchema": "",
  "ServerSideKmsKeyId": "",
  "ClientToken": "",
  "Tags": ""
}'

echo '{
  "DatasetName": "",
  "DatasetSchema": "",
  "ServerSideKmsKeyId": "",
  "ClientToken": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateDataset' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "DatasetName": "",\n  "DatasetSchema": "",\n  "ServerSideKmsKeyId": "",\n  "ClientToken": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateDataset'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "DatasetName": "",
  "DatasetSchema": "",
  "ServerSideKmsKeyId": "",
  "ClientToken": "",
  "Tags": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler

HEADERS

X-Amz-Target

BODY json

{
  "ModelName": "",
  "InferenceSchedulerName": "",
  "DataDelayOffsetInMinutes": "",
  "DataUploadFrequency": "",
  "DataInputConfiguration": "",
  "DataOutputConfiguration": "",
  "RoleArn": "",
  "ServerSideKmsKeyId": "",
  "ClientToken": "",
  "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=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler");

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  \"ModelName\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler" {:headers {:x-amz-target ""}
                                                                                                                      :content-type :json
                                                                                                                      :form-params {:ModelName ""
                                                                                                                                    :InferenceSchedulerName ""
                                                                                                                                    :DataDelayOffsetInMinutes ""
                                                                                                                                    :DataUploadFrequency ""
                                                                                                                                    :DataInputConfiguration ""
                                                                                                                                    :DataOutputConfiguration ""
                                                                                                                                    :RoleArn ""
                                                                                                                                    :ServerSideKmsKeyId ""
                                                                                                                                    :ClientToken ""
                                                                                                                                    :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ModelName\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"ClientToken\": \"\",\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=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ModelName\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"ClientToken\": \"\",\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=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ModelName\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"ClientToken\": \"\",\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=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler"

	payload := strings.NewReader("{\n  \"ModelName\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"ClientToken\": \"\",\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: 261

{
  "ModelName": "",
  "InferenceSchedulerName": "",
  "DataDelayOffsetInMinutes": "",
  "DataUploadFrequency": "",
  "DataInputConfiguration": "",
  "DataOutputConfiguration": "",
  "RoleArn": "",
  "ServerSideKmsKeyId": "",
  "ClientToken": "",
  "Tags": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ModelName\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ModelName\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"ClientToken\": \"\",\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  \"ModelName\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler")
  .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=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ModelName\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ModelName: '',
  InferenceSchedulerName: '',
  DataDelayOffsetInMinutes: '',
  DataUploadFrequency: '',
  DataInputConfiguration: '',
  DataOutputConfiguration: '',
  RoleArn: '',
  ServerSideKmsKeyId: '',
  ClientToken: '',
  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=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler');
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=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ModelName: '',
    InferenceSchedulerName: '',
    DataDelayOffsetInMinutes: '',
    DataUploadFrequency: '',
    DataInputConfiguration: '',
    DataOutputConfiguration: '',
    RoleArn: '',
    ServerSideKmsKeyId: '',
    ClientToken: '',
    Tags: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ModelName":"","InferenceSchedulerName":"","DataDelayOffsetInMinutes":"","DataUploadFrequency":"","DataInputConfiguration":"","DataOutputConfiguration":"","RoleArn":"","ServerSideKmsKeyId":"","ClientToken":"","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=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ModelName": "",\n  "InferenceSchedulerName": "",\n  "DataDelayOffsetInMinutes": "",\n  "DataUploadFrequency": "",\n  "DataInputConfiguration": "",\n  "DataOutputConfiguration": "",\n  "RoleArn": "",\n  "ServerSideKmsKeyId": "",\n  "ClientToken": "",\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  \"ModelName\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler")
  .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({
  ModelName: '',
  InferenceSchedulerName: '',
  DataDelayOffsetInMinutes: '',
  DataUploadFrequency: '',
  DataInputConfiguration: '',
  DataOutputConfiguration: '',
  RoleArn: '',
  ServerSideKmsKeyId: '',
  ClientToken: '',
  Tags: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ModelName: '',
    InferenceSchedulerName: '',
    DataDelayOffsetInMinutes: '',
    DataUploadFrequency: '',
    DataInputConfiguration: '',
    DataOutputConfiguration: '',
    RoleArn: '',
    ServerSideKmsKeyId: '',
    ClientToken: '',
    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=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler');

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

req.type('json');
req.send({
  ModelName: '',
  InferenceSchedulerName: '',
  DataDelayOffsetInMinutes: '',
  DataUploadFrequency: '',
  DataInputConfiguration: '',
  DataOutputConfiguration: '',
  RoleArn: '',
  ServerSideKmsKeyId: '',
  ClientToken: '',
  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=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ModelName: '',
    InferenceSchedulerName: '',
    DataDelayOffsetInMinutes: '',
    DataUploadFrequency: '',
    DataInputConfiguration: '',
    DataOutputConfiguration: '',
    RoleArn: '',
    ServerSideKmsKeyId: '',
    ClientToken: '',
    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=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ModelName":"","InferenceSchedulerName":"","DataDelayOffsetInMinutes":"","DataUploadFrequency":"","DataInputConfiguration":"","DataOutputConfiguration":"","RoleArn":"","ServerSideKmsKeyId":"","ClientToken":"","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 = @{ @"ModelName": @"",
                              @"InferenceSchedulerName": @"",
                              @"DataDelayOffsetInMinutes": @"",
                              @"DataUploadFrequency": @"",
                              @"DataInputConfiguration": @"",
                              @"DataOutputConfiguration": @"",
                              @"RoleArn": @"",
                              @"ServerSideKmsKeyId": @"",
                              @"ClientToken": @"",
                              @"Tags": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler"]
                                                       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=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ModelName\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler",
  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([
    'ModelName' => '',
    'InferenceSchedulerName' => '',
    'DataDelayOffsetInMinutes' => '',
    'DataUploadFrequency' => '',
    'DataInputConfiguration' => '',
    'DataOutputConfiguration' => '',
    'RoleArn' => '',
    'ServerSideKmsKeyId' => '',
    'ClientToken' => '',
    '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=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler', [
  'body' => '{
  "ModelName": "",
  "InferenceSchedulerName": "",
  "DataDelayOffsetInMinutes": "",
  "DataUploadFrequency": "",
  "DataInputConfiguration": "",
  "DataOutputConfiguration": "",
  "RoleArn": "",
  "ServerSideKmsKeyId": "",
  "ClientToken": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ModelName' => '',
  'InferenceSchedulerName' => '',
  'DataDelayOffsetInMinutes' => '',
  'DataUploadFrequency' => '',
  'DataInputConfiguration' => '',
  'DataOutputConfiguration' => '',
  'RoleArn' => '',
  'ServerSideKmsKeyId' => '',
  'ClientToken' => '',
  'Tags' => ''
]));

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

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

append(json_encode([
  'ModelName' => '',
  'InferenceSchedulerName' => '',
  'DataDelayOffsetInMinutes' => '',
  'DataUploadFrequency' => '',
  'DataInputConfiguration' => '',
  'DataOutputConfiguration' => '',
  'RoleArn' => '',
  'ServerSideKmsKeyId' => '',
  'ClientToken' => '',
  'Tags' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler');
$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=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ModelName": "",
  "InferenceSchedulerName": "",
  "DataDelayOffsetInMinutes": "",
  "DataUploadFrequency": "",
  "DataInputConfiguration": "",
  "DataOutputConfiguration": "",
  "RoleArn": "",
  "ServerSideKmsKeyId": "",
  "ClientToken": "",
  "Tags": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ModelName": "",
  "InferenceSchedulerName": "",
  "DataDelayOffsetInMinutes": "",
  "DataUploadFrequency": "",
  "DataInputConfiguration": "",
  "DataOutputConfiguration": "",
  "RoleArn": "",
  "ServerSideKmsKeyId": "",
  "ClientToken": "",
  "Tags": ""
}'

import http.client

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

payload = "{\n  \"ModelName\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"ClientToken\": \"\",\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=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler"

payload = {
    "ModelName": "",
    "InferenceSchedulerName": "",
    "DataDelayOffsetInMinutes": "",
    "DataUploadFrequency": "",
    "DataInputConfiguration": "",
    "DataOutputConfiguration": "",
    "RoleArn": "",
    "ServerSideKmsKeyId": "",
    "ClientToken": "",
    "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=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler"

payload <- "{\n  \"ModelName\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"ClientToken\": \"\",\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=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler")

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  \"ModelName\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"ClientToken\": \"\",\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  \"ModelName\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"ClientToken\": \"\",\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=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler";

    let payload = json!({
        "ModelName": "",
        "InferenceSchedulerName": "",
        "DataDelayOffsetInMinutes": "",
        "DataUploadFrequency": "",
        "DataInputConfiguration": "",
        "DataOutputConfiguration": "",
        "RoleArn": "",
        "ServerSideKmsKeyId": "",
        "ClientToken": "",
        "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=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ModelName": "",
  "InferenceSchedulerName": "",
  "DataDelayOffsetInMinutes": "",
  "DataUploadFrequency": "",
  "DataInputConfiguration": "",
  "DataOutputConfiguration": "",
  "RoleArn": "",
  "ServerSideKmsKeyId": "",
  "ClientToken": "",
  "Tags": ""
}'

echo '{
  "ModelName": "",
  "InferenceSchedulerName": "",
  "DataDelayOffsetInMinutes": "",
  "DataUploadFrequency": "",
  "DataInputConfiguration": "",
  "DataOutputConfiguration": "",
  "RoleArn": "",
  "ServerSideKmsKeyId": "",
  "ClientToken": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ModelName": "",\n  "InferenceSchedulerName": "",\n  "DataDelayOffsetInMinutes": "",\n  "DataUploadFrequency": "",\n  "DataInputConfiguration": "",\n  "DataOutputConfiguration": "",\n  "RoleArn": "",\n  "ServerSideKmsKeyId": "",\n  "ClientToken": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateInferenceScheduler'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ModelName": "",
  "InferenceSchedulerName": "",
  "DataDelayOffsetInMinutes": "",
  "DataUploadFrequency": "",
  "DataInputConfiguration": "",
  "DataOutputConfiguration": "",
  "RoleArn": "",
  "ServerSideKmsKeyId": "",
  "ClientToken": "",
  "Tags": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateLabel

HEADERS

X-Amz-Target

BODY json

{
  "LabelGroupName": "",
  "StartTime": "",
  "EndTime": "",
  "Rating": "",
  "FaultCode": "",
  "Notes": "",
  "Equipment": "",
  "ClientToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"LabelGroupName\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Rating\": \"\",\n  \"FaultCode\": \"\",\n  \"Notes\": \"\",\n  \"Equipment\": \"\",\n  \"ClientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateLabel" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:LabelGroupName ""
                                                                                                                       :StartTime ""
                                                                                                                       :EndTime ""
                                                                                                                       :Rating ""
                                                                                                                       :FaultCode ""
                                                                                                                       :Notes ""
                                                                                                                       :Equipment ""
                                                                                                                       :ClientToken ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateLabel"

	payload := strings.NewReader("{\n  \"LabelGroupName\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Rating\": \"\",\n  \"FaultCode\": \"\",\n  \"Notes\": \"\",\n  \"Equipment\": \"\",\n  \"ClientToken\": \"\"\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: 152

{
  "LabelGroupName": "",
  "StartTime": "",
  "EndTime": "",
  "Rating": "",
  "FaultCode": "",
  "Notes": "",
  "Equipment": "",
  "ClientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateLabel")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"LabelGroupName\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Rating\": \"\",\n  \"FaultCode\": \"\",\n  \"Notes\": \"\",\n  \"Equipment\": \"\",\n  \"ClientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateLabel"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"LabelGroupName\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Rating\": \"\",\n  \"FaultCode\": \"\",\n  \"Notes\": \"\",\n  \"Equipment\": \"\",\n  \"ClientToken\": \"\"\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  \"LabelGroupName\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Rating\": \"\",\n  \"FaultCode\": \"\",\n  \"Notes\": \"\",\n  \"Equipment\": \"\",\n  \"ClientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateLabel")
  .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=AWSLookoutEquipmentFrontendService.CreateLabel")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"LabelGroupName\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Rating\": \"\",\n  \"FaultCode\": \"\",\n  \"Notes\": \"\",\n  \"Equipment\": \"\",\n  \"ClientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  LabelGroupName: '',
  StartTime: '',
  EndTime: '',
  Rating: '',
  FaultCode: '',
  Notes: '',
  Equipment: '',
  ClientToken: ''
});

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=AWSLookoutEquipmentFrontendService.CreateLabel');
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=AWSLookoutEquipmentFrontendService.CreateLabel',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    LabelGroupName: '',
    StartTime: '',
    EndTime: '',
    Rating: '',
    FaultCode: '',
    Notes: '',
    Equipment: '',
    ClientToken: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateLabel';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"LabelGroupName":"","StartTime":"","EndTime":"","Rating":"","FaultCode":"","Notes":"","Equipment":"","ClientToken":""}'
};

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=AWSLookoutEquipmentFrontendService.CreateLabel',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "LabelGroupName": "",\n  "StartTime": "",\n  "EndTime": "",\n  "Rating": "",\n  "FaultCode": "",\n  "Notes": "",\n  "Equipment": "",\n  "ClientToken": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"LabelGroupName\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Rating\": \"\",\n  \"FaultCode\": \"\",\n  \"Notes\": \"\",\n  \"Equipment\": \"\",\n  \"ClientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateLabel")
  .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({
  LabelGroupName: '',
  StartTime: '',
  EndTime: '',
  Rating: '',
  FaultCode: '',
  Notes: '',
  Equipment: '',
  ClientToken: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateLabel',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    LabelGroupName: '',
    StartTime: '',
    EndTime: '',
    Rating: '',
    FaultCode: '',
    Notes: '',
    Equipment: '',
    ClientToken: ''
  },
  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=AWSLookoutEquipmentFrontendService.CreateLabel');

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

req.type('json');
req.send({
  LabelGroupName: '',
  StartTime: '',
  EndTime: '',
  Rating: '',
  FaultCode: '',
  Notes: '',
  Equipment: '',
  ClientToken: ''
});

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=AWSLookoutEquipmentFrontendService.CreateLabel',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    LabelGroupName: '',
    StartTime: '',
    EndTime: '',
    Rating: '',
    FaultCode: '',
    Notes: '',
    Equipment: '',
    ClientToken: ''
  }
};

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=AWSLookoutEquipmentFrontendService.CreateLabel';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"LabelGroupName":"","StartTime":"","EndTime":"","Rating":"","FaultCode":"","Notes":"","Equipment":"","ClientToken":""}'
};

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 = @{ @"LabelGroupName": @"",
                              @"StartTime": @"",
                              @"EndTime": @"",
                              @"Rating": @"",
                              @"FaultCode": @"",
                              @"Notes": @"",
                              @"Equipment": @"",
                              @"ClientToken": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateLabel"]
                                                       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=AWSLookoutEquipmentFrontendService.CreateLabel" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"LabelGroupName\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Rating\": \"\",\n  \"FaultCode\": \"\",\n  \"Notes\": \"\",\n  \"Equipment\": \"\",\n  \"ClientToken\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateLabel",
  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([
    'LabelGroupName' => '',
    'StartTime' => '',
    'EndTime' => '',
    'Rating' => '',
    'FaultCode' => '',
    'Notes' => '',
    'Equipment' => '',
    'ClientToken' => ''
  ]),
  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=AWSLookoutEquipmentFrontendService.CreateLabel', [
  'body' => '{
  "LabelGroupName": "",
  "StartTime": "",
  "EndTime": "",
  "Rating": "",
  "FaultCode": "",
  "Notes": "",
  "Equipment": "",
  "ClientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'LabelGroupName' => '',
  'StartTime' => '',
  'EndTime' => '',
  'Rating' => '',
  'FaultCode' => '',
  'Notes' => '',
  'Equipment' => '',
  'ClientToken' => ''
]));

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

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

append(json_encode([
  'LabelGroupName' => '',
  'StartTime' => '',
  'EndTime' => '',
  'Rating' => '',
  'FaultCode' => '',
  'Notes' => '',
  'Equipment' => '',
  'ClientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateLabel');
$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=AWSLookoutEquipmentFrontendService.CreateLabel' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "LabelGroupName": "",
  "StartTime": "",
  "EndTime": "",
  "Rating": "",
  "FaultCode": "",
  "Notes": "",
  "Equipment": "",
  "ClientToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateLabel' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "LabelGroupName": "",
  "StartTime": "",
  "EndTime": "",
  "Rating": "",
  "FaultCode": "",
  "Notes": "",
  "Equipment": "",
  "ClientToken": ""
}'

import http.client

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

payload = "{\n  \"LabelGroupName\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Rating\": \"\",\n  \"FaultCode\": \"\",\n  \"Notes\": \"\",\n  \"Equipment\": \"\",\n  \"ClientToken\": \"\"\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=AWSLookoutEquipmentFrontendService.CreateLabel"

payload = {
    "LabelGroupName": "",
    "StartTime": "",
    "EndTime": "",
    "Rating": "",
    "FaultCode": "",
    "Notes": "",
    "Equipment": "",
    "ClientToken": ""
}
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=AWSLookoutEquipmentFrontendService.CreateLabel"

payload <- "{\n  \"LabelGroupName\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Rating\": \"\",\n  \"FaultCode\": \"\",\n  \"Notes\": \"\",\n  \"Equipment\": \"\",\n  \"ClientToken\": \"\"\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=AWSLookoutEquipmentFrontendService.CreateLabel")

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  \"LabelGroupName\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Rating\": \"\",\n  \"FaultCode\": \"\",\n  \"Notes\": \"\",\n  \"Equipment\": \"\",\n  \"ClientToken\": \"\"\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  \"LabelGroupName\": \"\",\n  \"StartTime\": \"\",\n  \"EndTime\": \"\",\n  \"Rating\": \"\",\n  \"FaultCode\": \"\",\n  \"Notes\": \"\",\n  \"Equipment\": \"\",\n  \"ClientToken\": \"\"\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=AWSLookoutEquipmentFrontendService.CreateLabel";

    let payload = json!({
        "LabelGroupName": "",
        "StartTime": "",
        "EndTime": "",
        "Rating": "",
        "FaultCode": "",
        "Notes": "",
        "Equipment": "",
        "ClientToken": ""
    });

    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=AWSLookoutEquipmentFrontendService.CreateLabel' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "LabelGroupName": "",
  "StartTime": "",
  "EndTime": "",
  "Rating": "",
  "FaultCode": "",
  "Notes": "",
  "Equipment": "",
  "ClientToken": ""
}'

echo '{
  "LabelGroupName": "",
  "StartTime": "",
  "EndTime": "",
  "Rating": "",
  "FaultCode": "",
  "Notes": "",
  "Equipment": "",
  "ClientToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateLabel' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "LabelGroupName": "",\n  "StartTime": "",\n  "EndTime": "",\n  "Rating": "",\n  "FaultCode": "",\n  "Notes": "",\n  "Equipment": "",\n  "ClientToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateLabel'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "LabelGroupName": "",
  "StartTime": "",
  "EndTime": "",
  "Rating": "",
  "FaultCode": "",
  "Notes": "",
  "Equipment": "",
  "ClientToken": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateLabelGroup

HEADERS

X-Amz-Target

BODY json

{
  "LabelGroupName": "",
  "FaultCodes": "",
  "ClientToken": "",
  "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=AWSLookoutEquipmentFrontendService.CreateLabelGroup");

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  \"LabelGroupName\": \"\",\n  \"FaultCodes\": \"\",\n  \"ClientToken\": \"\",\n  \"Tags\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateLabelGroup" {:headers {:x-amz-target ""}
                                                                                                              :content-type :json
                                                                                                              :form-params {:LabelGroupName ""
                                                                                                                            :FaultCodes ""
                                                                                                                            :ClientToken ""
                                                                                                                            :Tags ""}})

require "http/client"

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

	payload := strings.NewReader("{\n  \"LabelGroupName\": \"\",\n  \"FaultCodes\": \"\",\n  \"ClientToken\": \"\",\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: 81

{
  "LabelGroupName": "",
  "FaultCodes": "",
  "ClientToken": "",
  "Tags": ""
}

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

client.close();

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

const data = JSON.stringify({
  LabelGroupName: '',
  FaultCodes: '',
  ClientToken: '',
  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=AWSLookoutEquipmentFrontendService.CreateLabelGroup');
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=AWSLookoutEquipmentFrontendService.CreateLabelGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {LabelGroupName: '', FaultCodes: '', ClientToken: '', Tags: ''}
};

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

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

const request = require('request');

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

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

req.type('json');
req.send({
  LabelGroupName: '',
  FaultCodes: '',
  ClientToken: '',
  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=AWSLookoutEquipmentFrontendService.CreateLabelGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {LabelGroupName: '', FaultCodes: '', ClientToken: '', 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=AWSLookoutEquipmentFrontendService.CreateLabelGroup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"LabelGroupName":"","FaultCodes":"","ClientToken":"","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 = @{ @"LabelGroupName": @"",
                              @"FaultCodes": @"",
                              @"ClientToken": @"",
                              @"Tags": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'LabelGroupName' => '',
  'FaultCodes' => '',
  'ClientToken' => '',
  'Tags' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"LabelGroupName\": \"\",\n  \"FaultCodes\": \"\",\n  \"ClientToken\": \"\",\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=AWSLookoutEquipmentFrontendService.CreateLabelGroup"

payload = {
    "LabelGroupName": "",
    "FaultCodes": "",
    "ClientToken": "",
    "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=AWSLookoutEquipmentFrontendService.CreateLabelGroup"

payload <- "{\n  \"LabelGroupName\": \"\",\n  \"FaultCodes\": \"\",\n  \"ClientToken\": \"\",\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=AWSLookoutEquipmentFrontendService.CreateLabelGroup")

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  \"LabelGroupName\": \"\",\n  \"FaultCodes\": \"\",\n  \"ClientToken\": \"\",\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  \"LabelGroupName\": \"\",\n  \"FaultCodes\": \"\",\n  \"ClientToken\": \"\",\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=AWSLookoutEquipmentFrontendService.CreateLabelGroup";

    let payload = json!({
        "LabelGroupName": "",
        "FaultCodes": "",
        "ClientToken": "",
        "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=AWSLookoutEquipmentFrontendService.CreateLabelGroup' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "LabelGroupName": "",
  "FaultCodes": "",
  "ClientToken": "",
  "Tags": ""
}'

echo '{
  "LabelGroupName": "",
  "FaultCodes": "",
  "ClientToken": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateLabelGroup' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "LabelGroupName": "",\n  "FaultCodes": "",\n  "ClientToken": "",\n  "Tags": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateLabelGroup'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateModel

HEADERS

X-Amz-Target

BODY json

{
  "ModelName": "",
  "DatasetName": "",
  "DatasetSchema": "",
  "LabelsInputConfiguration": "",
  "ClientToken": "",
  "TrainingDataStartTime": "",
  "TrainingDataEndTime": "",
  "EvaluationDataStartTime": "",
  "EvaluationDataEndTime": "",
  "RoleArn": "",
  "DataPreProcessingConfiguration": "",
  "ServerSideKmsKeyId": "",
  "Tags": "",
  "OffCondition": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"ModelName\": \"\",\n  \"DatasetName\": \"\",\n  \"DatasetSchema\": \"\",\n  \"LabelsInputConfiguration\": \"\",\n  \"ClientToken\": \"\",\n  \"TrainingDataStartTime\": \"\",\n  \"TrainingDataEndTime\": \"\",\n  \"EvaluationDataStartTime\": \"\",\n  \"EvaluationDataEndTime\": \"\",\n  \"RoleArn\": \"\",\n  \"DataPreProcessingConfiguration\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"OffCondition\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateModel" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:ModelName ""
                                                                                                                       :DatasetName ""
                                                                                                                       :DatasetSchema ""
                                                                                                                       :LabelsInputConfiguration ""
                                                                                                                       :ClientToken ""
                                                                                                                       :TrainingDataStartTime ""
                                                                                                                       :TrainingDataEndTime ""
                                                                                                                       :EvaluationDataStartTime ""
                                                                                                                       :EvaluationDataEndTime ""
                                                                                                                       :RoleArn ""
                                                                                                                       :DataPreProcessingConfiguration ""
                                                                                                                       :ServerSideKmsKeyId ""
                                                                                                                       :Tags ""
                                                                                                                       :OffCondition ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateModel"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"ModelName\": \"\",\n  \"DatasetName\": \"\",\n  \"DatasetSchema\": \"\",\n  \"LabelsInputConfiguration\": \"\",\n  \"ClientToken\": \"\",\n  \"TrainingDataStartTime\": \"\",\n  \"TrainingDataEndTime\": \"\",\n  \"EvaluationDataStartTime\": \"\",\n  \"EvaluationDataEndTime\": \"\",\n  \"RoleArn\": \"\",\n  \"DataPreProcessingConfiguration\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"OffCondition\": \"\"\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=AWSLookoutEquipmentFrontendService.CreateModel"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"ModelName\": \"\",\n  \"DatasetName\": \"\",\n  \"DatasetSchema\": \"\",\n  \"LabelsInputConfiguration\": \"\",\n  \"ClientToken\": \"\",\n  \"TrainingDataStartTime\": \"\",\n  \"TrainingDataEndTime\": \"\",\n  \"EvaluationDataStartTime\": \"\",\n  \"EvaluationDataEndTime\": \"\",\n  \"RoleArn\": \"\",\n  \"DataPreProcessingConfiguration\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"OffCondition\": \"\"\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=AWSLookoutEquipmentFrontendService.CreateModel");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"ModelName\": \"\",\n  \"DatasetName\": \"\",\n  \"DatasetSchema\": \"\",\n  \"LabelsInputConfiguration\": \"\",\n  \"ClientToken\": \"\",\n  \"TrainingDataStartTime\": \"\",\n  \"TrainingDataEndTime\": \"\",\n  \"EvaluationDataStartTime\": \"\",\n  \"EvaluationDataEndTime\": \"\",\n  \"RoleArn\": \"\",\n  \"DataPreProcessingConfiguration\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"OffCondition\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateModel"

	payload := strings.NewReader("{\n  \"ModelName\": \"\",\n  \"DatasetName\": \"\",\n  \"DatasetSchema\": \"\",\n  \"LabelsInputConfiguration\": \"\",\n  \"ClientToken\": \"\",\n  \"TrainingDataStartTime\": \"\",\n  \"TrainingDataEndTime\": \"\",\n  \"EvaluationDataStartTime\": \"\",\n  \"EvaluationDataEndTime\": \"\",\n  \"RoleArn\": \"\",\n  \"DataPreProcessingConfiguration\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"OffCondition\": \"\"\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: 365

{
  "ModelName": "",
  "DatasetName": "",
  "DatasetSchema": "",
  "LabelsInputConfiguration": "",
  "ClientToken": "",
  "TrainingDataStartTime": "",
  "TrainingDataEndTime": "",
  "EvaluationDataStartTime": "",
  "EvaluationDataEndTime": "",
  "RoleArn": "",
  "DataPreProcessingConfiguration": "",
  "ServerSideKmsKeyId": "",
  "Tags": "",
  "OffCondition": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateModel")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"ModelName\": \"\",\n  \"DatasetName\": \"\",\n  \"DatasetSchema\": \"\",\n  \"LabelsInputConfiguration\": \"\",\n  \"ClientToken\": \"\",\n  \"TrainingDataStartTime\": \"\",\n  \"TrainingDataEndTime\": \"\",\n  \"EvaluationDataStartTime\": \"\",\n  \"EvaluationDataEndTime\": \"\",\n  \"RoleArn\": \"\",\n  \"DataPreProcessingConfiguration\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"OffCondition\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateModel"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"ModelName\": \"\",\n  \"DatasetName\": \"\",\n  \"DatasetSchema\": \"\",\n  \"LabelsInputConfiguration\": \"\",\n  \"ClientToken\": \"\",\n  \"TrainingDataStartTime\": \"\",\n  \"TrainingDataEndTime\": \"\",\n  \"EvaluationDataStartTime\": \"\",\n  \"EvaluationDataEndTime\": \"\",\n  \"RoleArn\": \"\",\n  \"DataPreProcessingConfiguration\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"OffCondition\": \"\"\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  \"ModelName\": \"\",\n  \"DatasetName\": \"\",\n  \"DatasetSchema\": \"\",\n  \"LabelsInputConfiguration\": \"\",\n  \"ClientToken\": \"\",\n  \"TrainingDataStartTime\": \"\",\n  \"TrainingDataEndTime\": \"\",\n  \"EvaluationDataStartTime\": \"\",\n  \"EvaluationDataEndTime\": \"\",\n  \"RoleArn\": \"\",\n  \"DataPreProcessingConfiguration\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"OffCondition\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateModel")
  .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=AWSLookoutEquipmentFrontendService.CreateModel")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"ModelName\": \"\",\n  \"DatasetName\": \"\",\n  \"DatasetSchema\": \"\",\n  \"LabelsInputConfiguration\": \"\",\n  \"ClientToken\": \"\",\n  \"TrainingDataStartTime\": \"\",\n  \"TrainingDataEndTime\": \"\",\n  \"EvaluationDataStartTime\": \"\",\n  \"EvaluationDataEndTime\": \"\",\n  \"RoleArn\": \"\",\n  \"DataPreProcessingConfiguration\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"OffCondition\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  ModelName: '',
  DatasetName: '',
  DatasetSchema: '',
  LabelsInputConfiguration: '',
  ClientToken: '',
  TrainingDataStartTime: '',
  TrainingDataEndTime: '',
  EvaluationDataStartTime: '',
  EvaluationDataEndTime: '',
  RoleArn: '',
  DataPreProcessingConfiguration: '',
  ServerSideKmsKeyId: '',
  Tags: '',
  OffCondition: ''
});

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=AWSLookoutEquipmentFrontendService.CreateModel');
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=AWSLookoutEquipmentFrontendService.CreateModel',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ModelName: '',
    DatasetName: '',
    DatasetSchema: '',
    LabelsInputConfiguration: '',
    ClientToken: '',
    TrainingDataStartTime: '',
    TrainingDataEndTime: '',
    EvaluationDataStartTime: '',
    EvaluationDataEndTime: '',
    RoleArn: '',
    DataPreProcessingConfiguration: '',
    ServerSideKmsKeyId: '',
    Tags: '',
    OffCondition: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateModel';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ModelName":"","DatasetName":"","DatasetSchema":"","LabelsInputConfiguration":"","ClientToken":"","TrainingDataStartTime":"","TrainingDataEndTime":"","EvaluationDataStartTime":"","EvaluationDataEndTime":"","RoleArn":"","DataPreProcessingConfiguration":"","ServerSideKmsKeyId":"","Tags":"","OffCondition":""}'
};

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=AWSLookoutEquipmentFrontendService.CreateModel',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "ModelName": "",\n  "DatasetName": "",\n  "DatasetSchema": "",\n  "LabelsInputConfiguration": "",\n  "ClientToken": "",\n  "TrainingDataStartTime": "",\n  "TrainingDataEndTime": "",\n  "EvaluationDataStartTime": "",\n  "EvaluationDataEndTime": "",\n  "RoleArn": "",\n  "DataPreProcessingConfiguration": "",\n  "ServerSideKmsKeyId": "",\n  "Tags": "",\n  "OffCondition": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"ModelName\": \"\",\n  \"DatasetName\": \"\",\n  \"DatasetSchema\": \"\",\n  \"LabelsInputConfiguration\": \"\",\n  \"ClientToken\": \"\",\n  \"TrainingDataStartTime\": \"\",\n  \"TrainingDataEndTime\": \"\",\n  \"EvaluationDataStartTime\": \"\",\n  \"EvaluationDataEndTime\": \"\",\n  \"RoleArn\": \"\",\n  \"DataPreProcessingConfiguration\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"OffCondition\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateModel")
  .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({
  ModelName: '',
  DatasetName: '',
  DatasetSchema: '',
  LabelsInputConfiguration: '',
  ClientToken: '',
  TrainingDataStartTime: '',
  TrainingDataEndTime: '',
  EvaluationDataStartTime: '',
  EvaluationDataEndTime: '',
  RoleArn: '',
  DataPreProcessingConfiguration: '',
  ServerSideKmsKeyId: '',
  Tags: '',
  OffCondition: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateModel',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    ModelName: '',
    DatasetName: '',
    DatasetSchema: '',
    LabelsInputConfiguration: '',
    ClientToken: '',
    TrainingDataStartTime: '',
    TrainingDataEndTime: '',
    EvaluationDataStartTime: '',
    EvaluationDataEndTime: '',
    RoleArn: '',
    DataPreProcessingConfiguration: '',
    ServerSideKmsKeyId: '',
    Tags: '',
    OffCondition: ''
  },
  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=AWSLookoutEquipmentFrontendService.CreateModel');

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

req.type('json');
req.send({
  ModelName: '',
  DatasetName: '',
  DatasetSchema: '',
  LabelsInputConfiguration: '',
  ClientToken: '',
  TrainingDataStartTime: '',
  TrainingDataEndTime: '',
  EvaluationDataStartTime: '',
  EvaluationDataEndTime: '',
  RoleArn: '',
  DataPreProcessingConfiguration: '',
  ServerSideKmsKeyId: '',
  Tags: '',
  OffCondition: ''
});

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=AWSLookoutEquipmentFrontendService.CreateModel',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    ModelName: '',
    DatasetName: '',
    DatasetSchema: '',
    LabelsInputConfiguration: '',
    ClientToken: '',
    TrainingDataStartTime: '',
    TrainingDataEndTime: '',
    EvaluationDataStartTime: '',
    EvaluationDataEndTime: '',
    RoleArn: '',
    DataPreProcessingConfiguration: '',
    ServerSideKmsKeyId: '',
    Tags: '',
    OffCondition: ''
  }
};

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=AWSLookoutEquipmentFrontendService.CreateModel';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"ModelName":"","DatasetName":"","DatasetSchema":"","LabelsInputConfiguration":"","ClientToken":"","TrainingDataStartTime":"","TrainingDataEndTime":"","EvaluationDataStartTime":"","EvaluationDataEndTime":"","RoleArn":"","DataPreProcessingConfiguration":"","ServerSideKmsKeyId":"","Tags":"","OffCondition":""}'
};

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 = @{ @"ModelName": @"",
                              @"DatasetName": @"",
                              @"DatasetSchema": @"",
                              @"LabelsInputConfiguration": @"",
                              @"ClientToken": @"",
                              @"TrainingDataStartTime": @"",
                              @"TrainingDataEndTime": @"",
                              @"EvaluationDataStartTime": @"",
                              @"EvaluationDataEndTime": @"",
                              @"RoleArn": @"",
                              @"DataPreProcessingConfiguration": @"",
                              @"ServerSideKmsKeyId": @"",
                              @"Tags": @"",
                              @"OffCondition": @"" };

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

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateModel"]
                                                       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=AWSLookoutEquipmentFrontendService.CreateModel" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"ModelName\": \"\",\n  \"DatasetName\": \"\",\n  \"DatasetSchema\": \"\",\n  \"LabelsInputConfiguration\": \"\",\n  \"ClientToken\": \"\",\n  \"TrainingDataStartTime\": \"\",\n  \"TrainingDataEndTime\": \"\",\n  \"EvaluationDataStartTime\": \"\",\n  \"EvaluationDataEndTime\": \"\",\n  \"RoleArn\": \"\",\n  \"DataPreProcessingConfiguration\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"OffCondition\": \"\"\n}" in

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

 "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateModel",
  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([
    'ModelName' => '',
    'DatasetName' => '',
    'DatasetSchema' => '',
    'LabelsInputConfiguration' => '',
    'ClientToken' => '',
    'TrainingDataStartTime' => '',
    'TrainingDataEndTime' => '',
    'EvaluationDataStartTime' => '',
    'EvaluationDataEndTime' => '',
    'RoleArn' => '',
    'DataPreProcessingConfiguration' => '',
    'ServerSideKmsKeyId' => '',
    'Tags' => '',
    'OffCondition' => ''
  ]),
  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=AWSLookoutEquipmentFrontendService.CreateModel', [
  'body' => '{
  "ModelName": "",
  "DatasetName": "",
  "DatasetSchema": "",
  "LabelsInputConfiguration": "",
  "ClientToken": "",
  "TrainingDataStartTime": "",
  "TrainingDataEndTime": "",
  "EvaluationDataStartTime": "",
  "EvaluationDataEndTime": "",
  "RoleArn": "",
  "DataPreProcessingConfiguration": "",
  "ServerSideKmsKeyId": "",
  "Tags": "",
  "OffCondition": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'ModelName' => '',
  'DatasetName' => '',
  'DatasetSchema' => '',
  'LabelsInputConfiguration' => '',
  'ClientToken' => '',
  'TrainingDataStartTime' => '',
  'TrainingDataEndTime' => '',
  'EvaluationDataStartTime' => '',
  'EvaluationDataEndTime' => '',
  'RoleArn' => '',
  'DataPreProcessingConfiguration' => '',
  'ServerSideKmsKeyId' => '',
  'Tags' => '',
  'OffCondition' => ''
]));

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

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

append(json_encode([
  'ModelName' => '',
  'DatasetName' => '',
  'DatasetSchema' => '',
  'LabelsInputConfiguration' => '',
  'ClientToken' => '',
  'TrainingDataStartTime' => '',
  'TrainingDataEndTime' => '',
  'EvaluationDataStartTime' => '',
  'EvaluationDataEndTime' => '',
  'RoleArn' => '',
  'DataPreProcessingConfiguration' => '',
  'ServerSideKmsKeyId' => '',
  'Tags' => '',
  'OffCondition' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateModel');
$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=AWSLookoutEquipmentFrontendService.CreateModel' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ModelName": "",
  "DatasetName": "",
  "DatasetSchema": "",
  "LabelsInputConfiguration": "",
  "ClientToken": "",
  "TrainingDataStartTime": "",
  "TrainingDataEndTime": "",
  "EvaluationDataStartTime": "",
  "EvaluationDataEndTime": "",
  "RoleArn": "",
  "DataPreProcessingConfiguration": "",
  "ServerSideKmsKeyId": "",
  "Tags": "",
  "OffCondition": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateModel' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "ModelName": "",
  "DatasetName": "",
  "DatasetSchema": "",
  "LabelsInputConfiguration": "",
  "ClientToken": "",
  "TrainingDataStartTime": "",
  "TrainingDataEndTime": "",
  "EvaluationDataStartTime": "",
  "EvaluationDataEndTime": "",
  "RoleArn": "",
  "DataPreProcessingConfiguration": "",
  "ServerSideKmsKeyId": "",
  "Tags": "",
  "OffCondition": ""
}'

import http.client

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

payload = "{\n  \"ModelName\": \"\",\n  \"DatasetName\": \"\",\n  \"DatasetSchema\": \"\",\n  \"LabelsInputConfiguration\": \"\",\n  \"ClientToken\": \"\",\n  \"TrainingDataStartTime\": \"\",\n  \"TrainingDataEndTime\": \"\",\n  \"EvaluationDataStartTime\": \"\",\n  \"EvaluationDataEndTime\": \"\",\n  \"RoleArn\": \"\",\n  \"DataPreProcessingConfiguration\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"OffCondition\": \"\"\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=AWSLookoutEquipmentFrontendService.CreateModel"

payload = {
    "ModelName": "",
    "DatasetName": "",
    "DatasetSchema": "",
    "LabelsInputConfiguration": "",
    "ClientToken": "",
    "TrainingDataStartTime": "",
    "TrainingDataEndTime": "",
    "EvaluationDataStartTime": "",
    "EvaluationDataEndTime": "",
    "RoleArn": "",
    "DataPreProcessingConfiguration": "",
    "ServerSideKmsKeyId": "",
    "Tags": "",
    "OffCondition": ""
}
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=AWSLookoutEquipmentFrontendService.CreateModel"

payload <- "{\n  \"ModelName\": \"\",\n  \"DatasetName\": \"\",\n  \"DatasetSchema\": \"\",\n  \"LabelsInputConfiguration\": \"\",\n  \"ClientToken\": \"\",\n  \"TrainingDataStartTime\": \"\",\n  \"TrainingDataEndTime\": \"\",\n  \"EvaluationDataStartTime\": \"\",\n  \"EvaluationDataEndTime\": \"\",\n  \"RoleArn\": \"\",\n  \"DataPreProcessingConfiguration\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"OffCondition\": \"\"\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=AWSLookoutEquipmentFrontendService.CreateModel")

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  \"ModelName\": \"\",\n  \"DatasetName\": \"\",\n  \"DatasetSchema\": \"\",\n  \"LabelsInputConfiguration\": \"\",\n  \"ClientToken\": \"\",\n  \"TrainingDataStartTime\": \"\",\n  \"TrainingDataEndTime\": \"\",\n  \"EvaluationDataStartTime\": \"\",\n  \"EvaluationDataEndTime\": \"\",\n  \"RoleArn\": \"\",\n  \"DataPreProcessingConfiguration\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"OffCondition\": \"\"\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  \"ModelName\": \"\",\n  \"DatasetName\": \"\",\n  \"DatasetSchema\": \"\",\n  \"LabelsInputConfiguration\": \"\",\n  \"ClientToken\": \"\",\n  \"TrainingDataStartTime\": \"\",\n  \"TrainingDataEndTime\": \"\",\n  \"EvaluationDataStartTime\": \"\",\n  \"EvaluationDataEndTime\": \"\",\n  \"RoleArn\": \"\",\n  \"DataPreProcessingConfiguration\": \"\",\n  \"ServerSideKmsKeyId\": \"\",\n  \"Tags\": \"\",\n  \"OffCondition\": \"\"\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=AWSLookoutEquipmentFrontendService.CreateModel";

    let payload = json!({
        "ModelName": "",
        "DatasetName": "",
        "DatasetSchema": "",
        "LabelsInputConfiguration": "",
        "ClientToken": "",
        "TrainingDataStartTime": "",
        "TrainingDataEndTime": "",
        "EvaluationDataStartTime": "",
        "EvaluationDataEndTime": "",
        "RoleArn": "",
        "DataPreProcessingConfiguration": "",
        "ServerSideKmsKeyId": "",
        "Tags": "",
        "OffCondition": ""
    });

    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=AWSLookoutEquipmentFrontendService.CreateModel' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ModelName": "",
  "DatasetName": "",
  "DatasetSchema": "",
  "LabelsInputConfiguration": "",
  "ClientToken": "",
  "TrainingDataStartTime": "",
  "TrainingDataEndTime": "",
  "EvaluationDataStartTime": "",
  "EvaluationDataEndTime": "",
  "RoleArn": "",
  "DataPreProcessingConfiguration": "",
  "ServerSideKmsKeyId": "",
  "Tags": "",
  "OffCondition": ""
}'

echo '{
  "ModelName": "",
  "DatasetName": "",
  "DatasetSchema": "",
  "LabelsInputConfiguration": "",
  "ClientToken": "",
  "TrainingDataStartTime": "",
  "TrainingDataEndTime": "",
  "EvaluationDataStartTime": "",
  "EvaluationDataEndTime": "",
  "RoleArn": "",
  "DataPreProcessingConfiguration": "",
  "ServerSideKmsKeyId": "",
  "Tags": "",
  "OffCondition": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateModel' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "ModelName": "",\n  "DatasetName": "",\n  "DatasetSchema": "",\n  "LabelsInputConfiguration": "",\n  "ClientToken": "",\n  "TrainingDataStartTime": "",\n  "TrainingDataEndTime": "",\n  "EvaluationDataStartTime": "",\n  "EvaluationDataEndTime": "",\n  "RoleArn": "",\n  "DataPreProcessingConfiguration": "",\n  "ServerSideKmsKeyId": "",\n  "Tags": "",\n  "OffCondition": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.CreateModel'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "ModelName": "",
  "DatasetName": "",
  "DatasetSchema": "",
  "LabelsInputConfiguration": "",
  "ClientToken": "",
  "TrainingDataStartTime": "",
  "TrainingDataEndTime": "",
  "EvaluationDataStartTime": "",
  "EvaluationDataEndTime": "",
  "RoleArn": "",
  "DataPreProcessingConfiguration": "",
  "ServerSideKmsKeyId": "",
  "Tags": "",
  "OffCondition": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.DeleteDataset

HEADERS

X-Amz-Target

BODY json

{
  "DatasetName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.DeleteDataset"

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

{
  "DatasetName": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"DatasetName\": \"\"\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=AWSLookoutEquipmentFrontendService.DeleteDataset"

payload = { "DatasetName": "" }
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=AWSLookoutEquipmentFrontendService.DeleteDataset"

payload <- "{\n  \"DatasetName\": \"\"\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=AWSLookoutEquipmentFrontendService.DeleteDataset")

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  \"DatasetName\": \"\"\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  \"DatasetName\": \"\"\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=AWSLookoutEquipmentFrontendService.DeleteDataset";

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

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

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

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.DeleteInferenceScheduler

HEADERS

X-Amz-Target

BODY json

{
  "InferenceSchedulerName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.DeleteInferenceScheduler"

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

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

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

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

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

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

}

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

{
  "InferenceSchedulerName": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"InferenceSchedulerName\": \"\"\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=AWSLookoutEquipmentFrontendService.DeleteInferenceScheduler"

payload = { "InferenceSchedulerName": "" }
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=AWSLookoutEquipmentFrontendService.DeleteInferenceScheduler"

payload <- "{\n  \"InferenceSchedulerName\": \"\"\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=AWSLookoutEquipmentFrontendService.DeleteInferenceScheduler")

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  \"InferenceSchedulerName\": \"\"\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  \"InferenceSchedulerName\": \"\"\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=AWSLookoutEquipmentFrontendService.DeleteInferenceScheduler";

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

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

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

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.DeleteLabel

HEADERS

X-Amz-Target

BODY json

{
  "LabelGroupName": "",
  "LabelId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.DeleteLabel" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:LabelGroupName ""
                                                                                                                       :LabelId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.DeleteLabel"

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

{
  "LabelGroupName": "",
  "LabelId": ""
}

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

client.close();

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

const data = JSON.stringify({
  LabelGroupName: '',
  LabelId: ''
});

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=AWSLookoutEquipmentFrontendService.DeleteLabel');
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=AWSLookoutEquipmentFrontendService.DeleteLabel',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {LabelGroupName: '', LabelId: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  LabelGroupName: '',
  LabelId: ''
});

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=AWSLookoutEquipmentFrontendService.DeleteLabel',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {LabelGroupName: '', LabelId: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"LabelGroupName\": \"\",\n  \"LabelId\": \"\"\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=AWSLookoutEquipmentFrontendService.DeleteLabel"

payload = {
    "LabelGroupName": "",
    "LabelId": ""
}
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=AWSLookoutEquipmentFrontendService.DeleteLabel"

payload <- "{\n  \"LabelGroupName\": \"\",\n  \"LabelId\": \"\"\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=AWSLookoutEquipmentFrontendService.DeleteLabel")

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  \"LabelGroupName\": \"\",\n  \"LabelId\": \"\"\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  \"LabelGroupName\": \"\",\n  \"LabelId\": \"\"\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=AWSLookoutEquipmentFrontendService.DeleteLabel";

    let payload = json!({
        "LabelGroupName": "",
        "LabelId": ""
    });

    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=AWSLookoutEquipmentFrontendService.DeleteLabel' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "LabelGroupName": "",
  "LabelId": ""
}'

echo '{
  "LabelGroupName": "",
  "LabelId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.DeleteLabel' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.DeleteLabelGroup

HEADERS

X-Amz-Target

BODY json

{
  "LabelGroupName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.DeleteLabelGroup"

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

{
  "LabelGroupName": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"LabelGroupName\": \"\"\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=AWSLookoutEquipmentFrontendService.DeleteLabelGroup"

payload = { "LabelGroupName": "" }
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=AWSLookoutEquipmentFrontendService.DeleteLabelGroup"

payload <- "{\n  \"LabelGroupName\": \"\"\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=AWSLookoutEquipmentFrontendService.DeleteLabelGroup")

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  \"LabelGroupName\": \"\"\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  \"LabelGroupName\": \"\"\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=AWSLookoutEquipmentFrontendService.DeleteLabelGroup";

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

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

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

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.DeleteModel

HEADERS

X-Amz-Target

BODY json

{
  "ModelName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.DeleteModel"

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

{
  "ModelName": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"ModelName\": \"\"\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=AWSLookoutEquipmentFrontendService.DeleteModel"

payload = { "ModelName": "" }
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=AWSLookoutEquipmentFrontendService.DeleteModel"

payload <- "{\n  \"ModelName\": \"\"\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=AWSLookoutEquipmentFrontendService.DeleteModel")

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  \"ModelName\": \"\"\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  \"ModelName\": \"\"\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=AWSLookoutEquipmentFrontendService.DeleteModel";

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

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

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

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.DescribeDataIngestionJob

HEADERS

X-Amz-Target

BODY json

{
  "JobId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.DescribeDataIngestionJob"

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

{
  "JobId": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"JobId\": \"\"\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=AWSLookoutEquipmentFrontendService.DescribeDataIngestionJob"

payload = { "JobId": "" }
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=AWSLookoutEquipmentFrontendService.DescribeDataIngestionJob"

payload <- "{\n  \"JobId\": \"\"\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=AWSLookoutEquipmentFrontendService.DescribeDataIngestionJob")

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  \"JobId\": \"\"\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  \"JobId\": \"\"\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=AWSLookoutEquipmentFrontendService.DescribeDataIngestionJob";

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

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

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

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.DescribeDataset

HEADERS

X-Amz-Target

BODY json

{
  "DatasetName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.DescribeDataset"

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

{
  "DatasetName": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"DatasetName\": \"\"\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=AWSLookoutEquipmentFrontendService.DescribeDataset"

payload = { "DatasetName": "" }
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=AWSLookoutEquipmentFrontendService.DescribeDataset"

payload <- "{\n  \"DatasetName\": \"\"\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=AWSLookoutEquipmentFrontendService.DescribeDataset")

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  \"DatasetName\": \"\"\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  \"DatasetName\": \"\"\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=AWSLookoutEquipmentFrontendService.DescribeDataset";

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

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

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

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.DescribeInferenceScheduler

HEADERS

X-Amz-Target

BODY json

{
  "InferenceSchedulerName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.DescribeInferenceScheduler"

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

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

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

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

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

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

}

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

{
  "InferenceSchedulerName": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"InferenceSchedulerName\": \"\"\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=AWSLookoutEquipmentFrontendService.DescribeInferenceScheduler"

payload = { "InferenceSchedulerName": "" }
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=AWSLookoutEquipmentFrontendService.DescribeInferenceScheduler"

payload <- "{\n  \"InferenceSchedulerName\": \"\"\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=AWSLookoutEquipmentFrontendService.DescribeInferenceScheduler")

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  \"InferenceSchedulerName\": \"\"\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  \"InferenceSchedulerName\": \"\"\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=AWSLookoutEquipmentFrontendService.DescribeInferenceScheduler";

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

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

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

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.DescribeLabel

HEADERS

X-Amz-Target

BODY json

{
  "LabelGroupName": "",
  "LabelId": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.DescribeLabel" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:LabelGroupName ""
                                                                                                                         :LabelId ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.DescribeLabel"

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

{
  "LabelGroupName": "",
  "LabelId": ""
}

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

client.close();

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

const data = JSON.stringify({
  LabelGroupName: '',
  LabelId: ''
});

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=AWSLookoutEquipmentFrontendService.DescribeLabel');
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=AWSLookoutEquipmentFrontendService.DescribeLabel',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {LabelGroupName: '', LabelId: ''}
};

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  LabelGroupName: '',
  LabelId: ''
});

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=AWSLookoutEquipmentFrontendService.DescribeLabel',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {LabelGroupName: '', LabelId: ''}
};

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"LabelGroupName\": \"\",\n  \"LabelId\": \"\"\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=AWSLookoutEquipmentFrontendService.DescribeLabel"

payload = {
    "LabelGroupName": "",
    "LabelId": ""
}
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=AWSLookoutEquipmentFrontendService.DescribeLabel"

payload <- "{\n  \"LabelGroupName\": \"\",\n  \"LabelId\": \"\"\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=AWSLookoutEquipmentFrontendService.DescribeLabel")

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  \"LabelGroupName\": \"\",\n  \"LabelId\": \"\"\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  \"LabelGroupName\": \"\",\n  \"LabelId\": \"\"\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=AWSLookoutEquipmentFrontendService.DescribeLabel";

    let payload = json!({
        "LabelGroupName": "",
        "LabelId": ""
    });

    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=AWSLookoutEquipmentFrontendService.DescribeLabel' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "LabelGroupName": "",
  "LabelId": ""
}'

echo '{
  "LabelGroupName": "",
  "LabelId": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.DescribeLabel' \
  content-type:application/json \
  x-amz-target:''

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.DescribeLabelGroup

HEADERS

X-Amz-Target

BODY json

{
  "LabelGroupName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.DescribeLabelGroup"

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

{
  "LabelGroupName": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"LabelGroupName\": \"\"\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=AWSLookoutEquipmentFrontendService.DescribeLabelGroup"

payload = { "LabelGroupName": "" }
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=AWSLookoutEquipmentFrontendService.DescribeLabelGroup"

payload <- "{\n  \"LabelGroupName\": \"\"\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=AWSLookoutEquipmentFrontendService.DescribeLabelGroup")

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  \"LabelGroupName\": \"\"\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  \"LabelGroupName\": \"\"\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=AWSLookoutEquipmentFrontendService.DescribeLabelGroup";

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

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

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

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.DescribeModel

HEADERS

X-Amz-Target

BODY json

{
  "ModelName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

CURLcode ret = curl_easy_perform(hnd);

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

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

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.DescribeModel"

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

{
  "ModelName": ""
}

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

client.close();

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

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

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

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

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

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

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

val client = OkHttpClient()

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

const request = require('request');

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

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

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

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

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

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

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

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

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

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

echo $response->getBody();

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

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

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

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

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

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

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

import http.client

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

payload = "{\n  \"ModelName\": \"\"\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=AWSLookoutEquipmentFrontendService.DescribeModel"

payload = { "ModelName": "" }
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=AWSLookoutEquipmentFrontendService.DescribeModel"

payload <- "{\n  \"ModelName\": \"\"\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=AWSLookoutEquipmentFrontendService.DescribeModel")

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  \"ModelName\": \"\"\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  \"ModelName\": \"\"\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=AWSLookoutEquipmentFrontendService.DescribeModel";

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

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

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

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

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListDataIngestionJobs

HEADERS

X-Amz-Target

BODY json

{
  "DatasetName": "",
  "NextToken": "",
  "MaxResults": "",
  "Status": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"DatasetName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"Status\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListDataIngestionJobs" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:DatasetName ""
                                                                                                                                 :NextToken ""
                                                                                                                                 :MaxResults ""
                                                                                                                                 :Status ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListDataIngestionJobs"

	payload := strings.NewReader("{\n  \"DatasetName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"Status\": \"\"\n}")

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

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

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

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

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

}

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

{
  "DatasetName": "",
  "NextToken": "",
  "MaxResults": "",
  "Status": ""
}

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

client.close();

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

const data = JSON.stringify({
  DatasetName: '',
  NextToken: '',
  MaxResults: '',
  Status: ''
});

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=AWSLookoutEquipmentFrontendService.ListDataIngestionJobs');
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=AWSLookoutEquipmentFrontendService.ListDataIngestionJobs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {DatasetName: '', NextToken: '', MaxResults: '', Status: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListDataIngestionJobs';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DatasetName":"","NextToken":"","MaxResults":"","Status":""}'
};

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=AWSLookoutEquipmentFrontendService.ListDataIngestionJobs',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DatasetName": "",\n  "NextToken": "",\n  "MaxResults": "",\n  "Status": ""\n}'
};

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

val client = OkHttpClient()

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

const request = require('request');

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

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

req.type('json');
req.send({
  DatasetName: '',
  NextToken: '',
  MaxResults: '',
  Status: ''
});

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=AWSLookoutEquipmentFrontendService.ListDataIngestionJobs',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {DatasetName: '', NextToken: '', MaxResults: '', Status: ''}
};

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=AWSLookoutEquipmentFrontendService.ListDataIngestionJobs';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DatasetName":"","NextToken":"","MaxResults":"","Status":""}'
};

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 = @{ @"DatasetName": @"",
                              @"NextToken": @"",
                              @"MaxResults": @"",
                              @"Status": @"" };

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DatasetName' => '',
  'NextToken' => '',
  'MaxResults' => '',
  'Status' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"DatasetName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"Status\": \"\"\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=AWSLookoutEquipmentFrontendService.ListDataIngestionJobs"

payload = {
    "DatasetName": "",
    "NextToken": "",
    "MaxResults": "",
    "Status": ""
}
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=AWSLookoutEquipmentFrontendService.ListDataIngestionJobs"

payload <- "{\n  \"DatasetName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"Status\": \"\"\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=AWSLookoutEquipmentFrontendService.ListDataIngestionJobs")

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  \"DatasetName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"Status\": \"\"\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  \"DatasetName\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"Status\": \"\"\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=AWSLookoutEquipmentFrontendService.ListDataIngestionJobs";

    let payload = json!({
        "DatasetName": "",
        "NextToken": "",
        "MaxResults": "",
        "Status": ""
    });

    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=AWSLookoutEquipmentFrontendService.ListDataIngestionJobs' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "DatasetName": "",
  "NextToken": "",
  "MaxResults": "",
  "Status": ""
}'

echo '{
  "DatasetName": "",
  "NextToken": "",
  "MaxResults": "",
  "Status": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListDataIngestionJobs' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "DatasetName": "",\n  "NextToken": "",\n  "MaxResults": "",\n  "Status": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListDataIngestionJobs'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListDatasets

HEADERS

X-Amz-Target

BODY json

{
  "NextToken": "",
  "MaxResults": "",
  "DatasetNameBeginsWith": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"DatasetNameBeginsWith\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListDatasets" {:headers {:x-amz-target ""}
                                                                                                          :content-type :json
                                                                                                          :form-params {:NextToken ""
                                                                                                                        :MaxResults ""
                                                                                                                        :DatasetNameBeginsWith ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListDatasets"

	payload := strings.NewReader("{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"DatasetNameBeginsWith\": \"\"\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: 72

{
  "NextToken": "",
  "MaxResults": "",
  "DatasetNameBeginsWith": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"DatasetNameBeginsWith\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListDatasets")
  .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=AWSLookoutEquipmentFrontendService.ListDatasets")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"DatasetNameBeginsWith\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  NextToken: '',
  MaxResults: '',
  DatasetNameBeginsWith: ''
});

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=AWSLookoutEquipmentFrontendService.ListDatasets');
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=AWSLookoutEquipmentFrontendService.ListDatasets',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {NextToken: '', MaxResults: '', DatasetNameBeginsWith: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListDatasets';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"NextToken":"","MaxResults":"","DatasetNameBeginsWith":""}'
};

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

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

val client = OkHttpClient()

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

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({NextToken: '', MaxResults: '', DatasetNameBeginsWith: ''}));
req.end();

const request = require('request');

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

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

req.type('json');
req.send({
  NextToken: '',
  MaxResults: '',
  DatasetNameBeginsWith: ''
});

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=AWSLookoutEquipmentFrontendService.ListDatasets',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {NextToken: '', MaxResults: '', DatasetNameBeginsWith: ''}
};

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=AWSLookoutEquipmentFrontendService.ListDatasets';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"NextToken":"","MaxResults":"","DatasetNameBeginsWith":""}'
};

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

#import 

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

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

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

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

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

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'NextToken' => '',
  'MaxResults' => '',
  'DatasetNameBeginsWith' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"DatasetNameBeginsWith\": \"\"\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=AWSLookoutEquipmentFrontendService.ListDatasets"

payload = {
    "NextToken": "",
    "MaxResults": "",
    "DatasetNameBeginsWith": ""
}
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=AWSLookoutEquipmentFrontendService.ListDatasets"

payload <- "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"DatasetNameBeginsWith\": \"\"\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=AWSLookoutEquipmentFrontendService.ListDatasets")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"DatasetNameBeginsWith\": \"\"\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=AWSLookoutEquipmentFrontendService.ListDatasets";

    let payload = json!({
        "NextToken": "",
        "MaxResults": "",
        "DatasetNameBeginsWith": ""
    });

    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=AWSLookoutEquipmentFrontendService.ListDatasets' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "NextToken": "",
  "MaxResults": "",
  "DatasetNameBeginsWith": ""
}'

echo '{
  "NextToken": "",
  "MaxResults": "",
  "DatasetNameBeginsWith": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListDatasets' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "NextToken": "",\n  "MaxResults": "",\n  "DatasetNameBeginsWith": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListDatasets'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceEvents

HEADERS

X-Amz-Target

BODY json

{
  "NextToken": "",
  "MaxResults": "",
  "InferenceSchedulerName": "",
  "IntervalStartTime": "",
  "IntervalEndTime": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"IntervalStartTime\": \"\",\n  \"IntervalEndTime\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceEvents" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:NextToken ""
                                                                                                                               :MaxResults ""
                                                                                                                               :InferenceSchedulerName ""
                                                                                                                               :IntervalStartTime ""
                                                                                                                               :IntervalEndTime ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceEvents"

	payload := strings.NewReader("{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"IntervalStartTime\": \"\",\n  \"IntervalEndTime\": \"\"\n}")

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

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

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

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

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

}

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

{
  "NextToken": "",
  "MaxResults": "",
  "InferenceSchedulerName": "",
  "IntervalStartTime": "",
  "IntervalEndTime": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"IntervalStartTime\": \"\",\n  \"IntervalEndTime\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceEvents")
  .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=AWSLookoutEquipmentFrontendService.ListInferenceEvents")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"IntervalStartTime\": \"\",\n  \"IntervalEndTime\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  NextToken: '',
  MaxResults: '',
  InferenceSchedulerName: '',
  IntervalStartTime: '',
  IntervalEndTime: ''
});

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=AWSLookoutEquipmentFrontendService.ListInferenceEvents');
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=AWSLookoutEquipmentFrontendService.ListInferenceEvents',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    NextToken: '',
    MaxResults: '',
    InferenceSchedulerName: '',
    IntervalStartTime: '',
    IntervalEndTime: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceEvents';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"NextToken":"","MaxResults":"","InferenceSchedulerName":"","IntervalStartTime":"","IntervalEndTime":""}'
};

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=AWSLookoutEquipmentFrontendService.ListInferenceEvents',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "NextToken": "",\n  "MaxResults": "",\n  "InferenceSchedulerName": "",\n  "IntervalStartTime": "",\n  "IntervalEndTime": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"IntervalStartTime\": \"\",\n  \"IntervalEndTime\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceEvents")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  NextToken: '',
  MaxResults: '',
  InferenceSchedulerName: '',
  IntervalStartTime: '',
  IntervalEndTime: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceEvents',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    NextToken: '',
    MaxResults: '',
    InferenceSchedulerName: '',
    IntervalStartTime: '',
    IntervalEndTime: ''
  },
  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=AWSLookoutEquipmentFrontendService.ListInferenceEvents');

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

req.type('json');
req.send({
  NextToken: '',
  MaxResults: '',
  InferenceSchedulerName: '',
  IntervalStartTime: '',
  IntervalEndTime: ''
});

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=AWSLookoutEquipmentFrontendService.ListInferenceEvents',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    NextToken: '',
    MaxResults: '',
    InferenceSchedulerName: '',
    IntervalStartTime: '',
    IntervalEndTime: ''
  }
};

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=AWSLookoutEquipmentFrontendService.ListInferenceEvents';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"NextToken":"","MaxResults":"","InferenceSchedulerName":"","IntervalStartTime":"","IntervalEndTime":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"NextToken": @"",
                              @"MaxResults": @"",
                              @"InferenceSchedulerName": @"",
                              @"IntervalStartTime": @"",
                              @"IntervalEndTime": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceEvents",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'NextToken' => '',
    'MaxResults' => '',
    'InferenceSchedulerName' => '',
    'IntervalStartTime' => '',
    'IntervalEndTime' => ''
  ]),
  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=AWSLookoutEquipmentFrontendService.ListInferenceEvents', [
  'body' => '{
  "NextToken": "",
  "MaxResults": "",
  "InferenceSchedulerName": "",
  "IntervalStartTime": "",
  "IntervalEndTime": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'NextToken' => '',
  'MaxResults' => '',
  'InferenceSchedulerName' => '',
  'IntervalStartTime' => '',
  'IntervalEndTime' => ''
]));

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

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

append(json_encode([
  'NextToken' => '',
  'MaxResults' => '',
  'InferenceSchedulerName' => '',
  'IntervalStartTime' => '',
  'IntervalEndTime' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceEvents');
$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=AWSLookoutEquipmentFrontendService.ListInferenceEvents' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "NextToken": "",
  "MaxResults": "",
  "InferenceSchedulerName": "",
  "IntervalStartTime": "",
  "IntervalEndTime": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceEvents' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "NextToken": "",
  "MaxResults": "",
  "InferenceSchedulerName": "",
  "IntervalStartTime": "",
  "IntervalEndTime": ""
}'

import http.client

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

payload = "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"IntervalStartTime\": \"\",\n  \"IntervalEndTime\": \"\"\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=AWSLookoutEquipmentFrontendService.ListInferenceEvents"

payload = {
    "NextToken": "",
    "MaxResults": "",
    "InferenceSchedulerName": "",
    "IntervalStartTime": "",
    "IntervalEndTime": ""
}
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=AWSLookoutEquipmentFrontendService.ListInferenceEvents"

payload <- "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"IntervalStartTime\": \"\",\n  \"IntervalEndTime\": \"\"\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=AWSLookoutEquipmentFrontendService.ListInferenceEvents")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"IntervalStartTime\": \"\",\n  \"IntervalEndTime\": \"\"\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=AWSLookoutEquipmentFrontendService.ListInferenceEvents";

    let payload = json!({
        "NextToken": "",
        "MaxResults": "",
        "InferenceSchedulerName": "",
        "IntervalStartTime": "",
        "IntervalEndTime": ""
    });

    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=AWSLookoutEquipmentFrontendService.ListInferenceEvents' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "NextToken": "",
  "MaxResults": "",
  "InferenceSchedulerName": "",
  "IntervalStartTime": "",
  "IntervalEndTime": ""
}'

echo '{
  "NextToken": "",
  "MaxResults": "",
  "InferenceSchedulerName": "",
  "IntervalStartTime": "",
  "IntervalEndTime": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceEvents' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "NextToken": "",\n  "MaxResults": "",\n  "InferenceSchedulerName": "",\n  "IntervalStartTime": "",\n  "IntervalEndTime": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceEvents'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "NextToken": "",
  "MaxResults": "",
  "InferenceSchedulerName": "",
  "IntervalStartTime": "",
  "IntervalEndTime": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceExecutions

HEADERS

X-Amz-Target

BODY json

{
  "NextToken": "",
  "MaxResults": "",
  "InferenceSchedulerName": "",
  "DataStartTimeAfter": "",
  "DataEndTimeBefore": "",
  "Status": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"DataStartTimeAfter\": \"\",\n  \"DataEndTimeBefore\": \"\",\n  \"Status\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceExecutions" {:headers {:x-amz-target ""}
                                                                                                                     :content-type :json
                                                                                                                     :form-params {:NextToken ""
                                                                                                                                   :MaxResults ""
                                                                                                                                   :InferenceSchedulerName ""
                                                                                                                                   :DataStartTimeAfter ""
                                                                                                                                   :DataEndTimeBefore ""
                                                                                                                                   :Status ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceExecutions"

	payload := strings.NewReader("{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"DataStartTimeAfter\": \"\",\n  \"DataEndTimeBefore\": \"\",\n  \"Status\": \"\"\n}")

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

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

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

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

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

}

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

{
  "NextToken": "",
  "MaxResults": "",
  "InferenceSchedulerName": "",
  "DataStartTimeAfter": "",
  "DataEndTimeBefore": "",
  "Status": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceExecutions")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"DataStartTimeAfter\": \"\",\n  \"DataEndTimeBefore\": \"\",\n  \"Status\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"DataStartTimeAfter\": \"\",\n  \"DataEndTimeBefore\": \"\",\n  \"Status\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceExecutions")
  .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=AWSLookoutEquipmentFrontendService.ListInferenceExecutions")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"DataStartTimeAfter\": \"\",\n  \"DataEndTimeBefore\": \"\",\n  \"Status\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  NextToken: '',
  MaxResults: '',
  InferenceSchedulerName: '',
  DataStartTimeAfter: '',
  DataEndTimeBefore: '',
  Status: ''
});

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=AWSLookoutEquipmentFrontendService.ListInferenceExecutions');
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=AWSLookoutEquipmentFrontendService.ListInferenceExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    NextToken: '',
    MaxResults: '',
    InferenceSchedulerName: '',
    DataStartTimeAfter: '',
    DataEndTimeBefore: '',
    Status: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceExecutions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"NextToken":"","MaxResults":"","InferenceSchedulerName":"","DataStartTimeAfter":"","DataEndTimeBefore":"","Status":""}'
};

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=AWSLookoutEquipmentFrontendService.ListInferenceExecutions',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "NextToken": "",\n  "MaxResults": "",\n  "InferenceSchedulerName": "",\n  "DataStartTimeAfter": "",\n  "DataEndTimeBefore": "",\n  "Status": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"DataStartTimeAfter\": \"\",\n  \"DataEndTimeBefore\": \"\",\n  \"Status\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceExecutions")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  NextToken: '',
  MaxResults: '',
  InferenceSchedulerName: '',
  DataStartTimeAfter: '',
  DataEndTimeBefore: '',
  Status: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    NextToken: '',
    MaxResults: '',
    InferenceSchedulerName: '',
    DataStartTimeAfter: '',
    DataEndTimeBefore: '',
    Status: ''
  },
  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=AWSLookoutEquipmentFrontendService.ListInferenceExecutions');

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

req.type('json');
req.send({
  NextToken: '',
  MaxResults: '',
  InferenceSchedulerName: '',
  DataStartTimeAfter: '',
  DataEndTimeBefore: '',
  Status: ''
});

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=AWSLookoutEquipmentFrontendService.ListInferenceExecutions',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    NextToken: '',
    MaxResults: '',
    InferenceSchedulerName: '',
    DataStartTimeAfter: '',
    DataEndTimeBefore: '',
    Status: ''
  }
};

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=AWSLookoutEquipmentFrontendService.ListInferenceExecutions';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"NextToken":"","MaxResults":"","InferenceSchedulerName":"","DataStartTimeAfter":"","DataEndTimeBefore":"","Status":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"NextToken": @"",
                              @"MaxResults": @"",
                              @"InferenceSchedulerName": @"",
                              @"DataStartTimeAfter": @"",
                              @"DataEndTimeBefore": @"",
                              @"Status": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceExecutions",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'NextToken' => '',
    'MaxResults' => '',
    'InferenceSchedulerName' => '',
    'DataStartTimeAfter' => '',
    'DataEndTimeBefore' => '',
    'Status' => ''
  ]),
  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=AWSLookoutEquipmentFrontendService.ListInferenceExecutions', [
  'body' => '{
  "NextToken": "",
  "MaxResults": "",
  "InferenceSchedulerName": "",
  "DataStartTimeAfter": "",
  "DataEndTimeBefore": "",
  "Status": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'NextToken' => '',
  'MaxResults' => '',
  'InferenceSchedulerName' => '',
  'DataStartTimeAfter' => '',
  'DataEndTimeBefore' => '',
  'Status' => ''
]));

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

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

append(json_encode([
  'NextToken' => '',
  'MaxResults' => '',
  'InferenceSchedulerName' => '',
  'DataStartTimeAfter' => '',
  'DataEndTimeBefore' => '',
  'Status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceExecutions');
$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=AWSLookoutEquipmentFrontendService.ListInferenceExecutions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "NextToken": "",
  "MaxResults": "",
  "InferenceSchedulerName": "",
  "DataStartTimeAfter": "",
  "DataEndTimeBefore": "",
  "Status": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceExecutions' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "NextToken": "",
  "MaxResults": "",
  "InferenceSchedulerName": "",
  "DataStartTimeAfter": "",
  "DataEndTimeBefore": "",
  "Status": ""
}'

import http.client

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

payload = "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"DataStartTimeAfter\": \"\",\n  \"DataEndTimeBefore\": \"\",\n  \"Status\": \"\"\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=AWSLookoutEquipmentFrontendService.ListInferenceExecutions"

payload = {
    "NextToken": "",
    "MaxResults": "",
    "InferenceSchedulerName": "",
    "DataStartTimeAfter": "",
    "DataEndTimeBefore": "",
    "Status": ""
}
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=AWSLookoutEquipmentFrontendService.ListInferenceExecutions"

payload <- "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"DataStartTimeAfter\": \"\",\n  \"DataEndTimeBefore\": \"\",\n  \"Status\": \"\"\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=AWSLookoutEquipmentFrontendService.ListInferenceExecutions")

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

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"DataStartTimeAfter\": \"\",\n  \"DataEndTimeBefore\": \"\",\n  \"Status\": \"\"\n}"

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"InferenceSchedulerName\": \"\",\n  \"DataStartTimeAfter\": \"\",\n  \"DataEndTimeBefore\": \"\",\n  \"Status\": \"\"\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=AWSLookoutEquipmentFrontendService.ListInferenceExecutions";

    let payload = json!({
        "NextToken": "",
        "MaxResults": "",
        "InferenceSchedulerName": "",
        "DataStartTimeAfter": "",
        "DataEndTimeBefore": "",
        "Status": ""
    });

    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=AWSLookoutEquipmentFrontendService.ListInferenceExecutions' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "NextToken": "",
  "MaxResults": "",
  "InferenceSchedulerName": "",
  "DataStartTimeAfter": "",
  "DataEndTimeBefore": "",
  "Status": ""
}'

echo '{
  "NextToken": "",
  "MaxResults": "",
  "InferenceSchedulerName": "",
  "DataStartTimeAfter": "",
  "DataEndTimeBefore": "",
  "Status": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceExecutions' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "NextToken": "",\n  "MaxResults": "",\n  "InferenceSchedulerName": "",\n  "DataStartTimeAfter": "",\n  "DataEndTimeBefore": "",\n  "Status": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceExecutions'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "NextToken": "",
  "MaxResults": "",
  "InferenceSchedulerName": "",
  "DataStartTimeAfter": "",
  "DataEndTimeBefore": "",
  "Status": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceSchedulers

HEADERS

X-Amz-Target

BODY json

{
  "NextToken": "",
  "MaxResults": "",
  "InferenceSchedulerNameBeginsWith": "",
  "ModelName": "",
  "Status": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"InferenceSchedulerNameBeginsWith\": \"\",\n  \"ModelName\": \"\",\n  \"Status\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceSchedulers" {:headers {:x-amz-target ""}
                                                                                                                     :content-type :json
                                                                                                                     :form-params {:NextToken ""
                                                                                                                                   :MaxResults ""
                                                                                                                                   :InferenceSchedulerNameBeginsWith ""
                                                                                                                                   :ModelName ""
                                                                                                                                   :Status ""}})

require "http/client"

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceSchedulers"

	payload := strings.NewReader("{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"InferenceSchedulerNameBeginsWith\": \"\",\n  \"ModelName\": \"\",\n  \"Status\": \"\"\n}")

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

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

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

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

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

}

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

{
  "NextToken": "",
  "MaxResults": "",
  "InferenceSchedulerNameBeginsWith": "",
  "ModelName": "",
  "Status": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"InferenceSchedulerNameBeginsWith\": \"\",\n  \"ModelName\": \"\",\n  \"Status\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceSchedulers")
  .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=AWSLookoutEquipmentFrontendService.ListInferenceSchedulers")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"InferenceSchedulerNameBeginsWith\": \"\",\n  \"ModelName\": \"\",\n  \"Status\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  NextToken: '',
  MaxResults: '',
  InferenceSchedulerNameBeginsWith: '',
  ModelName: '',
  Status: ''
});

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=AWSLookoutEquipmentFrontendService.ListInferenceSchedulers');
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=AWSLookoutEquipmentFrontendService.ListInferenceSchedulers',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    NextToken: '',
    MaxResults: '',
    InferenceSchedulerNameBeginsWith: '',
    ModelName: '',
    Status: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceSchedulers';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"NextToken":"","MaxResults":"","InferenceSchedulerNameBeginsWith":"","ModelName":"","Status":""}'
};

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=AWSLookoutEquipmentFrontendService.ListInferenceSchedulers',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "NextToken": "",\n  "MaxResults": "",\n  "InferenceSchedulerNameBeginsWith": "",\n  "ModelName": "",\n  "Status": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"InferenceSchedulerNameBeginsWith\": \"\",\n  \"ModelName\": \"\",\n  \"Status\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceSchedulers")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

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

const http = require('https');

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

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

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

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

req.write(JSON.stringify({
  NextToken: '',
  MaxResults: '',
  InferenceSchedulerNameBeginsWith: '',
  ModelName: '',
  Status: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceSchedulers',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    NextToken: '',
    MaxResults: '',
    InferenceSchedulerNameBeginsWith: '',
    ModelName: '',
    Status: ''
  },
  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=AWSLookoutEquipmentFrontendService.ListInferenceSchedulers');

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

req.type('json');
req.send({
  NextToken: '',
  MaxResults: '',
  InferenceSchedulerNameBeginsWith: '',
  ModelName: '',
  Status: ''
});

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=AWSLookoutEquipmentFrontendService.ListInferenceSchedulers',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    NextToken: '',
    MaxResults: '',
    InferenceSchedulerNameBeginsWith: '',
    ModelName: '',
    Status: ''
  }
};

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=AWSLookoutEquipmentFrontendService.ListInferenceSchedulers';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"NextToken":"","MaxResults":"","InferenceSchedulerNameBeginsWith":"","ModelName":"","Status":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"NextToken": @"",
                              @"MaxResults": @"",
                              @"InferenceSchedulerNameBeginsWith": @"",
                              @"ModelName": @"",
                              @"Status": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceSchedulers",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'NextToken' => '',
    'MaxResults' => '',
    'InferenceSchedulerNameBeginsWith' => '',
    'ModelName' => '',
    'Status' => ''
  ]),
  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=AWSLookoutEquipmentFrontendService.ListInferenceSchedulers', [
  'body' => '{
  "NextToken": "",
  "MaxResults": "",
  "InferenceSchedulerNameBeginsWith": "",
  "ModelName": "",
  "Status": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'NextToken' => '',
  'MaxResults' => '',
  'InferenceSchedulerNameBeginsWith' => '',
  'ModelName' => '',
  'Status' => ''
]));

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

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

append(json_encode([
  'NextToken' => '',
  'MaxResults' => '',
  'InferenceSchedulerNameBeginsWith' => '',
  'ModelName' => '',
  'Status' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceSchedulers');
$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=AWSLookoutEquipmentFrontendService.ListInferenceSchedulers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "NextToken": "",
  "MaxResults": "",
  "InferenceSchedulerNameBeginsWith": "",
  "ModelName": "",
  "Status": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceSchedulers' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "NextToken": "",
  "MaxResults": "",
  "InferenceSchedulerNameBeginsWith": "",
  "ModelName": "",
  "Status": ""
}'

import http.client

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

payload = "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"InferenceSchedulerNameBeginsWith\": \"\",\n  \"ModelName\": \"\",\n  \"Status\": \"\"\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=AWSLookoutEquipmentFrontendService.ListInferenceSchedulers"

payload = {
    "NextToken": "",
    "MaxResults": "",
    "InferenceSchedulerNameBeginsWith": "",
    "ModelName": "",
    "Status": ""
}
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=AWSLookoutEquipmentFrontendService.ListInferenceSchedulers"

payload <- "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"InferenceSchedulerNameBeginsWith\": \"\",\n  \"ModelName\": \"\",\n  \"Status\": \"\"\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=AWSLookoutEquipmentFrontendService.ListInferenceSchedulers")

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

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

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

require 'faraday'

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

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"InferenceSchedulerNameBeginsWith\": \"\",\n  \"ModelName\": \"\",\n  \"Status\": \"\"\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=AWSLookoutEquipmentFrontendService.ListInferenceSchedulers";

    let payload = json!({
        "NextToken": "",
        "MaxResults": "",
        "InferenceSchedulerNameBeginsWith": "",
        "ModelName": "",
        "Status": ""
    });

    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=AWSLookoutEquipmentFrontendService.ListInferenceSchedulers' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "NextToken": "",
  "MaxResults": "",
  "InferenceSchedulerNameBeginsWith": "",
  "ModelName": "",
  "Status": ""
}'

echo '{
  "NextToken": "",
  "MaxResults": "",
  "InferenceSchedulerNameBeginsWith": "",
  "ModelName": "",
  "Status": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceSchedulers' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "NextToken": "",\n  "MaxResults": "",\n  "InferenceSchedulerNameBeginsWith": "",\n  "ModelName": "",\n  "Status": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListInferenceSchedulers'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "NextToken": "",
  "MaxResults": "",
  "InferenceSchedulerNameBeginsWith": "",
  "ModelName": "",
  "Status": ""
] as [String : Any]

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

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

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabelGroups

HEADERS

X-Amz-Target

BODY json

{
  "LabelGroupNameBeginsWith": "",
  "NextToken": "",
  "MaxResults": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"LabelGroupNameBeginsWith\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabelGroups" {:headers {:x-amz-target ""}
                                                                                                             :content-type :json
                                                                                                             :form-params {:LabelGroupNameBeginsWith ""
                                                                                                                           :NextToken ""
                                                                                                                           :MaxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabelGroups"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"LabelGroupNameBeginsWith\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

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

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

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

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabelGroups"

	payload := strings.NewReader("{\n  \"LabelGroupNameBeginsWith\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")

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

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

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

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

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

}

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

{
  "LabelGroupNameBeginsWith": "",
  "NextToken": "",
  "MaxResults": ""
}

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

client.close();

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

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"LabelGroupNameBeginsWith\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabelGroups")
  .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=AWSLookoutEquipmentFrontendService.ListLabelGroups")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"LabelGroupNameBeginsWith\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  LabelGroupNameBeginsWith: '',
  NextToken: '',
  MaxResults: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabelGroups');
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=AWSLookoutEquipmentFrontendService.ListLabelGroups',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {LabelGroupNameBeginsWith: '', NextToken: '', MaxResults: ''}
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabelGroups';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"LabelGroupNameBeginsWith":"","NextToken":"","MaxResults":""}'
};

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

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

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

val client = OkHttpClient()

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

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabelGroups',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {LabelGroupNameBeginsWith: '', NextToken: '', MaxResults: ''},
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  LabelGroupNameBeginsWith: '',
  NextToken: '',
  MaxResults: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabelGroups',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {LabelGroupNameBeginsWith: '', NextToken: '', MaxResults: ''}
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabelGroups';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"LabelGroupNameBeginsWith":"","NextToken":"","MaxResults":""}'
};

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

#import 

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

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabelGroups",
  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([
    'LabelGroupNameBeginsWith' => '',
    'NextToken' => '',
    'MaxResults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabelGroups', [
  'body' => '{
  "LabelGroupNameBeginsWith": "",
  "NextToken": "",
  "MaxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'LabelGroupNameBeginsWith' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));

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

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

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

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

import http.client

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

payload = "{\n  \"LabelGroupNameBeginsWith\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

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

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

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

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

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabelGroups"

payload = {
    "LabelGroupNameBeginsWith": "",
    "NextToken": "",
    "MaxResults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

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

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabelGroups"

payload <- "{\n  \"LabelGroupNameBeginsWith\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

encode <- "json"

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

content(response, "text")

require 'uri'
require 'net/http'

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

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  \"LabelGroupNameBeginsWith\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

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

require 'faraday'

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

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

puts response.status
puts response.body

use serde_json::json;
use reqwest;

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

    let payload = json!({
        "LabelGroupNameBeginsWith": "",
        "NextToken": "",
        "MaxResults": ""
    });

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

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

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

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabelGroups' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "LabelGroupNameBeginsWith": "",
  "NextToken": "",
  "MaxResults": ""
}'

echo '{
  "LabelGroupNameBeginsWith": "",
  "NextToken": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabelGroups' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "LabelGroupNameBeginsWith": "",\n  "NextToken": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabelGroups'

import Foundation

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

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

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

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels

HEADERS

X-Amz-Target

BODY json

{
  "LabelGroupName": "",
  "IntervalStartTime": "",
  "IntervalEndTime": "",
  "FaultCode": "",
  "Equipment": "",
  "NextToken": "",
  "MaxResults": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

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

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  \"LabelGroupName\": \"\",\n  \"IntervalStartTime\": \"\",\n  \"IntervalEndTime\": \"\",\n  \"FaultCode\": \"\",\n  \"Equipment\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

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

(client/post "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:LabelGroupName ""
                                                                                                                      :IntervalStartTime ""
                                                                                                                      :IntervalEndTime ""
                                                                                                                      :FaultCode ""
                                                                                                                      :Equipment ""
                                                                                                                      :NextToken ""
                                                                                                                      :MaxResults ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"LabelGroupName\": \"\",\n  \"IntervalStartTime\": \"\",\n  \"IntervalEndTime\": \"\",\n  \"FaultCode\": \"\",\n  \"Equipment\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

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

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

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"LabelGroupName\": \"\",\n  \"IntervalStartTime\": \"\",\n  \"IntervalEndTime\": \"\",\n  \"FaultCode\": \"\",\n  \"Equipment\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

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

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels"

	payload := strings.NewReader("{\n  \"LabelGroupName\": \"\",\n  \"IntervalStartTime\": \"\",\n  \"IntervalEndTime\": \"\",\n  \"FaultCode\": \"\",\n  \"Equipment\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")

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

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

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

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

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

}

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

{
  "LabelGroupName": "",
  "IntervalStartTime": "",
  "IntervalEndTime": "",
  "FaultCode": "",
  "Equipment": "",
  "NextToken": "",
  "MaxResults": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"LabelGroupName\": \"\",\n  \"IntervalStartTime\": \"\",\n  \"IntervalEndTime\": \"\",\n  \"FaultCode\": \"\",\n  \"Equipment\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"LabelGroupName\": \"\",\n  \"IntervalStartTime\": \"\",\n  \"IntervalEndTime\": \"\",\n  \"FaultCode\": \"\",\n  \"Equipment\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"LabelGroupName\": \"\",\n  \"IntervalStartTime\": \"\",\n  \"IntervalEndTime\": \"\",\n  \"FaultCode\": \"\",\n  \"Equipment\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels")
  .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=AWSLookoutEquipmentFrontendService.ListLabels")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"LabelGroupName\": \"\",\n  \"IntervalStartTime\": \"\",\n  \"IntervalEndTime\": \"\",\n  \"FaultCode\": \"\",\n  \"Equipment\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  LabelGroupName: '',
  IntervalStartTime: '',
  IntervalEndTime: '',
  FaultCode: '',
  Equipment: '',
  NextToken: '',
  MaxResults: ''
});

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

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

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels');
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=AWSLookoutEquipmentFrontendService.ListLabels',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    LabelGroupName: '',
    IntervalStartTime: '',
    IntervalEndTime: '',
    FaultCode: '',
    Equipment: '',
    NextToken: '',
    MaxResults: ''
  }
};

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"LabelGroupName":"","IntervalStartTime":"","IntervalEndTime":"","FaultCode":"","Equipment":"","NextToken":"","MaxResults":""}'
};

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

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "LabelGroupName": "",\n  "IntervalStartTime": "",\n  "IntervalEndTime": "",\n  "FaultCode": "",\n  "Equipment": "",\n  "NextToken": "",\n  "MaxResults": ""\n}'
};

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

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"LabelGroupName\": \"\",\n  \"IntervalStartTime\": \"\",\n  \"IntervalEndTime\": \"\",\n  \"FaultCode\": \"\",\n  \"Equipment\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels")
  .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({
  LabelGroupName: '',
  IntervalStartTime: '',
  IntervalEndTime: '',
  FaultCode: '',
  Equipment: '',
  NextToken: '',
  MaxResults: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    LabelGroupName: '',
    IntervalStartTime: '',
    IntervalEndTime: '',
    FaultCode: '',
    Equipment: '',
    NextToken: '',
    MaxResults: ''
  },
  json: true
};

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

  console.log(body);
});

const unirest = require('unirest');

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

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

req.type('json');
req.send({
  LabelGroupName: '',
  IntervalStartTime: '',
  IntervalEndTime: '',
  FaultCode: '',
  Equipment: '',
  NextToken: '',
  MaxResults: ''
});

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

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

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

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    LabelGroupName: '',
    IntervalStartTime: '',
    IntervalEndTime: '',
    FaultCode: '',
    Equipment: '',
    NextToken: '',
    MaxResults: ''
  }
};

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

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

const url = '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"LabelGroupName":"","IntervalStartTime":"","IntervalEndTime":"","FaultCode":"","Equipment":"","NextToken":"","MaxResults":""}'
};

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

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"LabelGroupName": @"",
                              @"IntervalStartTime": @"",
                              @"IntervalEndTime": @"",
                              @"FaultCode": @"",
                              @"Equipment": @"",
                              @"NextToken": @"",
                              @"MaxResults": @"" };

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

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

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

 "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels",
  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([
    'LabelGroupName' => '',
    'IntervalStartTime' => '',
    'IntervalEndTime' => '',
    'FaultCode' => '',
    'Equipment' => '',
    'NextToken' => '',
    'MaxResults' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

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

curl_close($curl);

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

request('POST', '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels', [
  'body' => '{
  "LabelGroupName": "",
  "IntervalStartTime": "",
  "IntervalEndTime": "",
  "FaultCode": "",
  "Equipment": "",
  "NextToken": "",
  "MaxResults": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

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

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

$request->setContentType('application/json');
$request->setBody(json_encode([
  'LabelGroupName' => '',
  'IntervalStartTime' => '',
  'IntervalEndTime' => '',
  'FaultCode' => '',
  'Equipment' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));

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

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

append(json_encode([
  'LabelGroupName' => '',
  'IntervalStartTime' => '',
  'IntervalEndTime' => '',
  'FaultCode' => '',
  'Equipment' => '',
  'NextToken' => '',
  'MaxResults' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels');
$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=AWSLookoutEquipmentFrontendService.ListLabels' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "LabelGroupName": "",
  "IntervalStartTime": "",
  "IntervalEndTime": "",
  "FaultCode": "",
  "Equipment": "",
  "NextToken": "",
  "MaxResults": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "LabelGroupName": "",
  "IntervalStartTime": "",
  "IntervalEndTime": "",
  "FaultCode": "",
  "Equipment": "",
  "NextToken": "",
  "MaxResults": ""
}'

import http.client

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

payload = "{\n  \"LabelGroupName\": \"\",\n  \"IntervalStartTime\": \"\",\n  \"IntervalEndTime\": \"\",\n  \"FaultCode\": \"\",\n  \"Equipment\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels"

payload = {
    "LabelGroupName": "",
    "IntervalStartTime": "",
    "IntervalEndTime": "",
    "FaultCode": "",
    "Equipment": "",
    "NextToken": "",
    "MaxResults": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels"

payload <- "{\n  \"LabelGroupName\": \"\",\n  \"IntervalStartTime\": \"\",\n  \"IntervalEndTime\": \"\",\n  \"FaultCode\": \"\",\n  \"Equipment\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels")

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  \"LabelGroupName\": \"\",\n  \"IntervalStartTime\": \"\",\n  \"IntervalEndTime\": \"\",\n  \"FaultCode\": \"\",\n  \"Equipment\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"LabelGroupName\": \"\",\n  \"IntervalStartTime\": \"\",\n  \"IntervalEndTime\": \"\",\n  \"FaultCode\": \"\",\n  \"Equipment\": \"\",\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels";

    let payload = json!({
        "LabelGroupName": "",
        "IntervalStartTime": "",
        "IntervalEndTime": "",
        "FaultCode": "",
        "Equipment": "",
        "NextToken": "",
        "MaxResults": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "LabelGroupName": "",
  "IntervalStartTime": "",
  "IntervalEndTime": "",
  "FaultCode": "",
  "Equipment": "",
  "NextToken": "",
  "MaxResults": ""
}'

echo '{
  "LabelGroupName": "",
  "IntervalStartTime": "",
  "IntervalEndTime": "",
  "FaultCode": "",
  "Equipment": "",
  "NextToken": "",
  "MaxResults": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "LabelGroupName": "",\n  "IntervalStartTime": "",\n  "IntervalEndTime": "",\n  "FaultCode": "",\n  "Equipment": "",\n  "NextToken": "",\n  "MaxResults": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "LabelGroupName": "",
  "IntervalStartTime": "",
  "IntervalEndTime": "",
  "FaultCode": "",
  "Equipment": "",
  "NextToken": "",
  "MaxResults": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListLabels")! 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 ListModels

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListModels

HEADERS

X-Amz-Target

BODY json

{
  "NextToken": "",
  "MaxResults": "",
  "Status": "",
  "ModelNameBeginsWith": "",
  "DatasetNameBeginsWith": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListModels");

struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
headers = curl_slist_append(headers, "content-type: application/json");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);

curl_easy_setopt(hnd, CURLOPT_POSTFIELDS, "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"Status\": \"\",\n  \"ModelNameBeginsWith\": \"\",\n  \"DatasetNameBeginsWith\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListModels" {:headers {:x-amz-target ""}
                                                                                                        :content-type :json
                                                                                                        :form-params {:NextToken ""
                                                                                                                      :MaxResults ""
                                                                                                                      :Status ""
                                                                                                                      :ModelNameBeginsWith ""
                                                                                                                      :DatasetNameBeginsWith ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListModels"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"Status\": \"\",\n  \"ModelNameBeginsWith\": \"\",\n  \"DatasetNameBeginsWith\": \"\"\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=AWSLookoutEquipmentFrontendService.ListModels"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"Status\": \"\",\n  \"ModelNameBeginsWith\": \"\",\n  \"DatasetNameBeginsWith\": \"\"\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=AWSLookoutEquipmentFrontendService.ListModels");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"Status\": \"\",\n  \"ModelNameBeginsWith\": \"\",\n  \"DatasetNameBeginsWith\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListModels"

	payload := strings.NewReader("{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"Status\": \"\",\n  \"ModelNameBeginsWith\": \"\",\n  \"DatasetNameBeginsWith\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 117

{
  "NextToken": "",
  "MaxResults": "",
  "Status": "",
  "ModelNameBeginsWith": "",
  "DatasetNameBeginsWith": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListModels")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"Status\": \"\",\n  \"ModelNameBeginsWith\": \"\",\n  \"DatasetNameBeginsWith\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListModels"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"Status\": \"\",\n  \"ModelNameBeginsWith\": \"\",\n  \"DatasetNameBeginsWith\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"Status\": \"\",\n  \"ModelNameBeginsWith\": \"\",\n  \"DatasetNameBeginsWith\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListModels")
  .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=AWSLookoutEquipmentFrontendService.ListModels")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"Status\": \"\",\n  \"ModelNameBeginsWith\": \"\",\n  \"DatasetNameBeginsWith\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  NextToken: '',
  MaxResults: '',
  Status: '',
  ModelNameBeginsWith: '',
  DatasetNameBeginsWith: ''
});

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=AWSLookoutEquipmentFrontendService.ListModels');
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=AWSLookoutEquipmentFrontendService.ListModels',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    NextToken: '',
    MaxResults: '',
    Status: '',
    ModelNameBeginsWith: '',
    DatasetNameBeginsWith: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListModels';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"NextToken":"","MaxResults":"","Status":"","ModelNameBeginsWith":"","DatasetNameBeginsWith":""}'
};

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=AWSLookoutEquipmentFrontendService.ListModels',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "NextToken": "",\n  "MaxResults": "",\n  "Status": "",\n  "ModelNameBeginsWith": "",\n  "DatasetNameBeginsWith": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"Status\": \"\",\n  \"ModelNameBeginsWith\": \"\",\n  \"DatasetNameBeginsWith\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListModels")
  .post(body)
  .addHeader("x-amz-target", "")
  .addHeader("content-type", "application/json")
  .build()

val response = client.newCall(request).execute()

const http = require('https');

const options = {
  method: 'POST',
  hostname: 'example.com',
  port: null,
  path: '/baseUrl/',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  }
};

const req = http.request(options, function (res) {
  const chunks = [];

  res.on('data', function (chunk) {
    chunks.push(chunk);
  });

  res.on('end', function () {
    const body = Buffer.concat(chunks);
    console.log(body.toString());
  });
});

req.write(JSON.stringify({
  NextToken: '',
  MaxResults: '',
  Status: '',
  ModelNameBeginsWith: '',
  DatasetNameBeginsWith: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListModels',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    NextToken: '',
    MaxResults: '',
    Status: '',
    ModelNameBeginsWith: '',
    DatasetNameBeginsWith: ''
  },
  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=AWSLookoutEquipmentFrontendService.ListModels');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  NextToken: '',
  MaxResults: '',
  Status: '',
  ModelNameBeginsWith: '',
  DatasetNameBeginsWith: ''
});

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=AWSLookoutEquipmentFrontendService.ListModels',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    NextToken: '',
    MaxResults: '',
    Status: '',
    ModelNameBeginsWith: '',
    DatasetNameBeginsWith: ''
  }
};

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=AWSLookoutEquipmentFrontendService.ListModels';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"NextToken":"","MaxResults":"","Status":"","ModelNameBeginsWith":"","DatasetNameBeginsWith":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"NextToken": @"",
                              @"MaxResults": @"",
                              @"Status": @"",
                              @"ModelNameBeginsWith": @"",
                              @"DatasetNameBeginsWith": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListModels"]
                                                       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=AWSLookoutEquipmentFrontendService.ListModels" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"Status\": \"\",\n  \"ModelNameBeginsWith\": \"\",\n  \"DatasetNameBeginsWith\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListModels",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'NextToken' => '',
    'MaxResults' => '',
    'Status' => '',
    'ModelNameBeginsWith' => '',
    'DatasetNameBeginsWith' => ''
  ]),
  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=AWSLookoutEquipmentFrontendService.ListModels', [
  'body' => '{
  "NextToken": "",
  "MaxResults": "",
  "Status": "",
  "ModelNameBeginsWith": "",
  "DatasetNameBeginsWith": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListModels');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'NextToken' => '',
  'MaxResults' => '',
  'Status' => '',
  'ModelNameBeginsWith' => '',
  'DatasetNameBeginsWith' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'NextToken' => '',
  'MaxResults' => '',
  'Status' => '',
  'ModelNameBeginsWith' => '',
  'DatasetNameBeginsWith' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListModels');
$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=AWSLookoutEquipmentFrontendService.ListModels' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "NextToken": "",
  "MaxResults": "",
  "Status": "",
  "ModelNameBeginsWith": "",
  "DatasetNameBeginsWith": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListModels' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "NextToken": "",
  "MaxResults": "",
  "Status": "",
  "ModelNameBeginsWith": "",
  "DatasetNameBeginsWith": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"Status\": \"\",\n  \"ModelNameBeginsWith\": \"\",\n  \"DatasetNameBeginsWith\": \"\"\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=AWSLookoutEquipmentFrontendService.ListModels"

payload = {
    "NextToken": "",
    "MaxResults": "",
    "Status": "",
    "ModelNameBeginsWith": "",
    "DatasetNameBeginsWith": ""
}
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=AWSLookoutEquipmentFrontendService.ListModels"

payload <- "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"Status\": \"\",\n  \"ModelNameBeginsWith\": \"\",\n  \"DatasetNameBeginsWith\": \"\"\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=AWSLookoutEquipmentFrontendService.ListModels")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
request["content-type"] = 'application/json'
request.body = "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"Status\": \"\",\n  \"ModelNameBeginsWith\": \"\",\n  \"DatasetNameBeginsWith\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"NextToken\": \"\",\n  \"MaxResults\": \"\",\n  \"Status\": \"\",\n  \"ModelNameBeginsWith\": \"\",\n  \"DatasetNameBeginsWith\": \"\"\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=AWSLookoutEquipmentFrontendService.ListModels";

    let payload = json!({
        "NextToken": "",
        "MaxResults": "",
        "Status": "",
        "ModelNameBeginsWith": "",
        "DatasetNameBeginsWith": ""
    });

    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=AWSLookoutEquipmentFrontendService.ListModels' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "NextToken": "",
  "MaxResults": "",
  "Status": "",
  "ModelNameBeginsWith": "",
  "DatasetNameBeginsWith": ""
}'

echo '{
  "NextToken": "",
  "MaxResults": "",
  "Status": "",
  "ModelNameBeginsWith": "",
  "DatasetNameBeginsWith": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListModels' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "NextToken": "",\n  "MaxResults": "",\n  "Status": "",\n  "ModelNameBeginsWith": "",\n  "DatasetNameBeginsWith": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListModels'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "NextToken": "",
  "MaxResults": "",
  "Status": "",
  "ModelNameBeginsWith": "",
  "DatasetNameBeginsWith": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListModels")! 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 ListSensorStatistics

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics

HEADERS

X-Amz-Target

BODY json

{
  "DatasetName": "",
  "IngestionJobId": "",
  "MaxResults": "",
  "NextToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics");

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  \"DatasetName\": \"\",\n  \"IngestionJobId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics" {:headers {:x-amz-target ""}
                                                                                                                  :content-type :json
                                                                                                                  :form-params {:DatasetName ""
                                                                                                                                :IngestionJobId ""
                                                                                                                                :MaxResults ""
                                                                                                                                :NextToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"DatasetName\": \"\",\n  \"IngestionJobId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"DatasetName\": \"\",\n  \"IngestionJobId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DatasetName\": \"\",\n  \"IngestionJobId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics"

	payload := strings.NewReader("{\n  \"DatasetName\": \"\",\n  \"IngestionJobId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 86

{
  "DatasetName": "",
  "IngestionJobId": "",
  "MaxResults": "",
  "NextToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DatasetName\": \"\",\n  \"IngestionJobId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DatasetName\": \"\",\n  \"IngestionJobId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"DatasetName\": \"\",\n  \"IngestionJobId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics")
  .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=AWSLookoutEquipmentFrontendService.ListSensorStatistics")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"DatasetName\": \"\",\n  \"IngestionJobId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  DatasetName: '',
  IngestionJobId: '',
  MaxResults: '',
  NextToken: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics');
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=AWSLookoutEquipmentFrontendService.ListSensorStatistics',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {DatasetName: '', IngestionJobId: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DatasetName":"","IngestionJobId":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DatasetName": "",\n  "IngestionJobId": "",\n  "MaxResults": "",\n  "NextToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DatasetName\": \"\",\n  \"IngestionJobId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics")
  .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({DatasetName: '', IngestionJobId: '', MaxResults: '', NextToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {DatasetName: '', IngestionJobId: '', MaxResults: '', NextToken: ''},
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  DatasetName: '',
  IngestionJobId: '',
  MaxResults: '',
  NextToken: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {DatasetName: '', IngestionJobId: '', MaxResults: '', NextToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DatasetName":"","IngestionJobId":"","MaxResults":"","NextToken":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"DatasetName": @"",
                              @"IngestionJobId": @"",
                              @"MaxResults": @"",
                              @"NextToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics"]
                                                       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=AWSLookoutEquipmentFrontendService.ListSensorStatistics" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"DatasetName\": \"\",\n  \"IngestionJobId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics",
  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([
    'DatasetName' => '',
    'IngestionJobId' => '',
    'MaxResults' => '',
    'NextToken' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics', [
  'body' => '{
  "DatasetName": "",
  "IngestionJobId": "",
  "MaxResults": "",
  "NextToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DatasetName' => '',
  'IngestionJobId' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'DatasetName' => '',
  'IngestionJobId' => '',
  'MaxResults' => '',
  'NextToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics');
$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=AWSLookoutEquipmentFrontendService.ListSensorStatistics' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DatasetName": "",
  "IngestionJobId": "",
  "MaxResults": "",
  "NextToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DatasetName": "",
  "IngestionJobId": "",
  "MaxResults": "",
  "NextToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"DatasetName\": \"\",\n  \"IngestionJobId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics"

payload = {
    "DatasetName": "",
    "IngestionJobId": "",
    "MaxResults": "",
    "NextToken": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics"

payload <- "{\n  \"DatasetName\": \"\",\n  \"IngestionJobId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics")

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  \"DatasetName\": \"\",\n  \"IngestionJobId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"DatasetName\": \"\",\n  \"IngestionJobId\": \"\",\n  \"MaxResults\": \"\",\n  \"NextToken\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics";

    let payload = json!({
        "DatasetName": "",
        "IngestionJobId": "",
        "MaxResults": "",
        "NextToken": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "DatasetName": "",
  "IngestionJobId": "",
  "MaxResults": "",
  "NextToken": ""
}'

echo '{
  "DatasetName": "",
  "IngestionJobId": "",
  "MaxResults": "",
  "NextToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "DatasetName": "",\n  "IngestionJobId": "",\n  "MaxResults": "",\n  "NextToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "DatasetName": "",
  "IngestionJobId": "",
  "MaxResults": "",
  "NextToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.ListSensorStatistics")! 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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.ListTagsForResource" {:headers {:x-amz-target ""}
                                                                                                                 :content-type :json
                                                                                                                 :form-params {:ResourceArn ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.ListTagsForResource', [
  'body' => '{
  "ResourceArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.ListTagsForResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceArn": ""
}'

echo '{
  "ResourceArn": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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 StartDataIngestionJob

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartDataIngestionJob

HEADERS

X-Amz-Target

BODY json

{
  "DatasetName": "",
  "IngestionInputConfiguration": "",
  "RoleArn": "",
  "ClientToken": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartDataIngestionJob");

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  \"DatasetName\": \"\",\n  \"IngestionInputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ClientToken\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartDataIngestionJob" {:headers {:x-amz-target ""}
                                                                                                                   :content-type :json
                                                                                                                   :form-params {:DatasetName ""
                                                                                                                                 :IngestionInputConfiguration ""
                                                                                                                                 :RoleArn ""
                                                                                                                                 :ClientToken ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartDataIngestionJob"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"DatasetName\": \"\",\n  \"IngestionInputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ClientToken\": \"\"\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=AWSLookoutEquipmentFrontendService.StartDataIngestionJob"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"DatasetName\": \"\",\n  \"IngestionInputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ClientToken\": \"\"\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=AWSLookoutEquipmentFrontendService.StartDataIngestionJob");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"DatasetName\": \"\",\n  \"IngestionInputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ClientToken\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartDataIngestionJob"

	payload := strings.NewReader("{\n  \"DatasetName\": \"\",\n  \"IngestionInputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ClientToken\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 98

{
  "DatasetName": "",
  "IngestionInputConfiguration": "",
  "RoleArn": "",
  "ClientToken": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartDataIngestionJob")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"DatasetName\": \"\",\n  \"IngestionInputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ClientToken\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartDataIngestionJob"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"DatasetName\": \"\",\n  \"IngestionInputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ClientToken\": \"\"\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  \"DatasetName\": \"\",\n  \"IngestionInputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ClientToken\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartDataIngestionJob")
  .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=AWSLookoutEquipmentFrontendService.StartDataIngestionJob")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"DatasetName\": \"\",\n  \"IngestionInputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ClientToken\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  DatasetName: '',
  IngestionInputConfiguration: '',
  RoleArn: '',
  ClientToken: ''
});

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=AWSLookoutEquipmentFrontendService.StartDataIngestionJob');
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=AWSLookoutEquipmentFrontendService.StartDataIngestionJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {DatasetName: '', IngestionInputConfiguration: '', RoleArn: '', ClientToken: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartDataIngestionJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DatasetName":"","IngestionInputConfiguration":"","RoleArn":"","ClientToken":""}'
};

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=AWSLookoutEquipmentFrontendService.StartDataIngestionJob',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "DatasetName": "",\n  "IngestionInputConfiguration": "",\n  "RoleArn": "",\n  "ClientToken": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"DatasetName\": \"\",\n  \"IngestionInputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ClientToken\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartDataIngestionJob")
  .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({DatasetName: '', IngestionInputConfiguration: '', RoleArn: '', ClientToken: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartDataIngestionJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {DatasetName: '', IngestionInputConfiguration: '', RoleArn: '', ClientToken: ''},
  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=AWSLookoutEquipmentFrontendService.StartDataIngestionJob');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  DatasetName: '',
  IngestionInputConfiguration: '',
  RoleArn: '',
  ClientToken: ''
});

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=AWSLookoutEquipmentFrontendService.StartDataIngestionJob',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {DatasetName: '', IngestionInputConfiguration: '', RoleArn: '', ClientToken: ''}
};

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=AWSLookoutEquipmentFrontendService.StartDataIngestionJob';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"DatasetName":"","IngestionInputConfiguration":"","RoleArn":"","ClientToken":""}'
};

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 = @{ @"DatasetName": @"",
                              @"IngestionInputConfiguration": @"",
                              @"RoleArn": @"",
                              @"ClientToken": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartDataIngestionJob"]
                                                       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=AWSLookoutEquipmentFrontendService.StartDataIngestionJob" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"DatasetName\": \"\",\n  \"IngestionInputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ClientToken\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartDataIngestionJob",
  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([
    'DatasetName' => '',
    'IngestionInputConfiguration' => '',
    'RoleArn' => '',
    'ClientToken' => ''
  ]),
  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=AWSLookoutEquipmentFrontendService.StartDataIngestionJob', [
  'body' => '{
  "DatasetName": "",
  "IngestionInputConfiguration": "",
  "RoleArn": "",
  "ClientToken": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartDataIngestionJob');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'DatasetName' => '',
  'IngestionInputConfiguration' => '',
  'RoleArn' => '',
  'ClientToken' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'DatasetName' => '',
  'IngestionInputConfiguration' => '',
  'RoleArn' => '',
  'ClientToken' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartDataIngestionJob');
$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=AWSLookoutEquipmentFrontendService.StartDataIngestionJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DatasetName": "",
  "IngestionInputConfiguration": "",
  "RoleArn": "",
  "ClientToken": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartDataIngestionJob' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "DatasetName": "",
  "IngestionInputConfiguration": "",
  "RoleArn": "",
  "ClientToken": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"DatasetName\": \"\",\n  \"IngestionInputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ClientToken\": \"\"\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=AWSLookoutEquipmentFrontendService.StartDataIngestionJob"

payload = {
    "DatasetName": "",
    "IngestionInputConfiguration": "",
    "RoleArn": "",
    "ClientToken": ""
}
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=AWSLookoutEquipmentFrontendService.StartDataIngestionJob"

payload <- "{\n  \"DatasetName\": \"\",\n  \"IngestionInputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ClientToken\": \"\"\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=AWSLookoutEquipmentFrontendService.StartDataIngestionJob")

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  \"DatasetName\": \"\",\n  \"IngestionInputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ClientToken\": \"\"\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  \"DatasetName\": \"\",\n  \"IngestionInputConfiguration\": \"\",\n  \"RoleArn\": \"\",\n  \"ClientToken\": \"\"\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=AWSLookoutEquipmentFrontendService.StartDataIngestionJob";

    let payload = json!({
        "DatasetName": "",
        "IngestionInputConfiguration": "",
        "RoleArn": "",
        "ClientToken": ""
    });

    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=AWSLookoutEquipmentFrontendService.StartDataIngestionJob' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "DatasetName": "",
  "IngestionInputConfiguration": "",
  "RoleArn": "",
  "ClientToken": ""
}'

echo '{
  "DatasetName": "",
  "IngestionInputConfiguration": "",
  "RoleArn": "",
  "ClientToken": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartDataIngestionJob' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "DatasetName": "",\n  "IngestionInputConfiguration": "",\n  "RoleArn": "",\n  "ClientToken": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartDataIngestionJob'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "DatasetName": "",
  "IngestionInputConfiguration": "",
  "RoleArn": "",
  "ClientToken": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartDataIngestionJob")! 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 StartInferenceScheduler

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartInferenceScheduler

HEADERS

X-Amz-Target

BODY json

{
  "InferenceSchedulerName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartInferenceScheduler");

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  \"InferenceSchedulerName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartInferenceScheduler" {:headers {:x-amz-target ""}
                                                                                                                     :content-type :json
                                                                                                                     :form-params {:InferenceSchedulerName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartInferenceScheduler"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"InferenceSchedulerName\": \"\"\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=AWSLookoutEquipmentFrontendService.StartInferenceScheduler"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"InferenceSchedulerName\": \"\"\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=AWSLookoutEquipmentFrontendService.StartInferenceScheduler");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"InferenceSchedulerName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartInferenceScheduler"

	payload := strings.NewReader("{\n  \"InferenceSchedulerName\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 34

{
  "InferenceSchedulerName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartInferenceScheduler")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"InferenceSchedulerName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartInferenceScheduler"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"InferenceSchedulerName\": \"\"\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  \"InferenceSchedulerName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartInferenceScheduler")
  .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=AWSLookoutEquipmentFrontendService.StartInferenceScheduler")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"InferenceSchedulerName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  InferenceSchedulerName: ''
});

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=AWSLookoutEquipmentFrontendService.StartInferenceScheduler');
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=AWSLookoutEquipmentFrontendService.StartInferenceScheduler',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {InferenceSchedulerName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartInferenceScheduler';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"InferenceSchedulerName":""}'
};

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=AWSLookoutEquipmentFrontendService.StartInferenceScheduler',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "InferenceSchedulerName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"InferenceSchedulerName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartInferenceScheduler")
  .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({InferenceSchedulerName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartInferenceScheduler',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {InferenceSchedulerName: ''},
  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=AWSLookoutEquipmentFrontendService.StartInferenceScheduler');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  InferenceSchedulerName: ''
});

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=AWSLookoutEquipmentFrontendService.StartInferenceScheduler',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {InferenceSchedulerName: ''}
};

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=AWSLookoutEquipmentFrontendService.StartInferenceScheduler';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"InferenceSchedulerName":""}'
};

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 = @{ @"InferenceSchedulerName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartInferenceScheduler"]
                                                       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=AWSLookoutEquipmentFrontendService.StartInferenceScheduler" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"InferenceSchedulerName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartInferenceScheduler",
  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([
    'InferenceSchedulerName' => ''
  ]),
  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=AWSLookoutEquipmentFrontendService.StartInferenceScheduler', [
  'body' => '{
  "InferenceSchedulerName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartInferenceScheduler');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'InferenceSchedulerName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'InferenceSchedulerName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartInferenceScheduler');
$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=AWSLookoutEquipmentFrontendService.StartInferenceScheduler' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InferenceSchedulerName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartInferenceScheduler' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InferenceSchedulerName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"InferenceSchedulerName\": \"\"\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=AWSLookoutEquipmentFrontendService.StartInferenceScheduler"

payload = { "InferenceSchedulerName": "" }
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=AWSLookoutEquipmentFrontendService.StartInferenceScheduler"

payload <- "{\n  \"InferenceSchedulerName\": \"\"\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=AWSLookoutEquipmentFrontendService.StartInferenceScheduler")

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  \"InferenceSchedulerName\": \"\"\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  \"InferenceSchedulerName\": \"\"\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=AWSLookoutEquipmentFrontendService.StartInferenceScheduler";

    let payload = json!({"InferenceSchedulerName": ""});

    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=AWSLookoutEquipmentFrontendService.StartInferenceScheduler' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "InferenceSchedulerName": ""
}'

echo '{
  "InferenceSchedulerName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartInferenceScheduler' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "InferenceSchedulerName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartInferenceScheduler'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["InferenceSchedulerName": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StartInferenceScheduler")! 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 StopInferenceScheduler

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StopInferenceScheduler

HEADERS

X-Amz-Target

BODY json

{
  "InferenceSchedulerName": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StopInferenceScheduler");

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  \"InferenceSchedulerName\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StopInferenceScheduler" {:headers {:x-amz-target ""}
                                                                                                                    :content-type :json
                                                                                                                    :form-params {:InferenceSchedulerName ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StopInferenceScheduler"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"InferenceSchedulerName\": \"\"\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=AWSLookoutEquipmentFrontendService.StopInferenceScheduler"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"InferenceSchedulerName\": \"\"\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=AWSLookoutEquipmentFrontendService.StopInferenceScheduler");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"InferenceSchedulerName\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StopInferenceScheduler"

	payload := strings.NewReader("{\n  \"InferenceSchedulerName\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 34

{
  "InferenceSchedulerName": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StopInferenceScheduler")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"InferenceSchedulerName\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StopInferenceScheduler"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"InferenceSchedulerName\": \"\"\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  \"InferenceSchedulerName\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StopInferenceScheduler")
  .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=AWSLookoutEquipmentFrontendService.StopInferenceScheduler")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"InferenceSchedulerName\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  InferenceSchedulerName: ''
});

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=AWSLookoutEquipmentFrontendService.StopInferenceScheduler');
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=AWSLookoutEquipmentFrontendService.StopInferenceScheduler',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {InferenceSchedulerName: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StopInferenceScheduler';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"InferenceSchedulerName":""}'
};

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=AWSLookoutEquipmentFrontendService.StopInferenceScheduler',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "InferenceSchedulerName": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"InferenceSchedulerName\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StopInferenceScheduler")
  .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({InferenceSchedulerName: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StopInferenceScheduler',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {InferenceSchedulerName: ''},
  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=AWSLookoutEquipmentFrontendService.StopInferenceScheduler');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  InferenceSchedulerName: ''
});

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=AWSLookoutEquipmentFrontendService.StopInferenceScheduler',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {InferenceSchedulerName: ''}
};

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=AWSLookoutEquipmentFrontendService.StopInferenceScheduler';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"InferenceSchedulerName":""}'
};

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 = @{ @"InferenceSchedulerName": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StopInferenceScheduler"]
                                                       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=AWSLookoutEquipmentFrontendService.StopInferenceScheduler" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"InferenceSchedulerName\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StopInferenceScheduler",
  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([
    'InferenceSchedulerName' => ''
  ]),
  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=AWSLookoutEquipmentFrontendService.StopInferenceScheduler', [
  'body' => '{
  "InferenceSchedulerName": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StopInferenceScheduler');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'InferenceSchedulerName' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'InferenceSchedulerName' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StopInferenceScheduler');
$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=AWSLookoutEquipmentFrontendService.StopInferenceScheduler' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InferenceSchedulerName": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StopInferenceScheduler' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InferenceSchedulerName": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"InferenceSchedulerName\": \"\"\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=AWSLookoutEquipmentFrontendService.StopInferenceScheduler"

payload = { "InferenceSchedulerName": "" }
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=AWSLookoutEquipmentFrontendService.StopInferenceScheduler"

payload <- "{\n  \"InferenceSchedulerName\": \"\"\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=AWSLookoutEquipmentFrontendService.StopInferenceScheduler")

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  \"InferenceSchedulerName\": \"\"\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  \"InferenceSchedulerName\": \"\"\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=AWSLookoutEquipmentFrontendService.StopInferenceScheduler";

    let payload = json!({"InferenceSchedulerName": ""});

    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=AWSLookoutEquipmentFrontendService.StopInferenceScheduler' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "InferenceSchedulerName": ""
}'

echo '{
  "InferenceSchedulerName": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StopInferenceScheduler' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "InferenceSchedulerName": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StopInferenceScheduler'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = ["InferenceSchedulerName": ""] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.StopInferenceScheduler")! 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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.TagResource" {:headers {:x-amz-target ""}
                                                                                                         :content-type :json
                                                                                                         :form-params {:ResourceArn ""
                                                                                                                       :Tags ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.TagResource', [
  'body' => '{
  "ResourceArn": "",
  "Tags": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.TagResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceArn": "",
  "Tags": ""
}'

echo '{
  "ResourceArn": "",
  "Tags": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.UntagResource" {:headers {:x-amz-target ""}
                                                                                                           :content-type :json
                                                                                                           :form-params {:ResourceArn ""
                                                                                                                         :TagKeys ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.UntagResource', [
  'body' => '{
  "ResourceArn": "",
  "TagKeys": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.UntagResource' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "ResourceArn": "",
  "TagKeys": ""
}'

echo '{
  "ResourceArn": "",
  "TagKeys": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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=AWSLookoutEquipmentFrontendService.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 UpdateInferenceScheduler

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler

HEADERS

X-Amz-Target

BODY json

{
  "InferenceSchedulerName": "",
  "DataDelayOffsetInMinutes": "",
  "DataUploadFrequency": "",
  "DataInputConfiguration": "",
  "DataOutputConfiguration": "",
  "RoleArn": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler");

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  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler" {:headers {:x-amz-target ""}
                                                                                                                      :content-type :json
                                                                                                                      :form-params {:InferenceSchedulerName ""
                                                                                                                                    :DataDelayOffsetInMinutes ""
                                                                                                                                    :DataUploadFrequency ""
                                                                                                                                    :DataInputConfiguration ""
                                                                                                                                    :DataOutputConfiguration ""
                                                                                                                                    :RoleArn ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\"\n}"

response = HTTP::Client.post url, headers: headers, body: reqBody
puts response.body

using System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
    Method = HttpMethod.Post,
    RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\"\n}")
    {
        Headers =
        {
            ContentType = new MediaTypeHeaderValue("application/json")
        }
    }
};
using (var response = await client.SendAsync(request))
{
    response.EnsureSuccessStatusCode();
    var body = await response.Content.ReadAsStringAsync();
    Console.WriteLine(body);
}

var client = new RestClient("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler"

	payload := strings.NewReader("{\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 179

{
  "InferenceSchedulerName": "",
  "DataDelayOffsetInMinutes": "",
  "DataUploadFrequency": "",
  "DataInputConfiguration": "",
  "DataOutputConfiguration": "",
  "RoleArn": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\"\n}"))
    .build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

OkHttpClient client = new OkHttpClient();

MediaType mediaType = MediaType.parse("application/json");
RequestBody body = RequestBody.create(mediaType, "{\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler")
  .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=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  InferenceSchedulerName: '',
  DataDelayOffsetInMinutes: '',
  DataUploadFrequency: '',
  DataInputConfiguration: '',
  DataOutputConfiguration: '',
  RoleArn: ''
});

const xhr = new XMLHttpRequest();
xhr.withCredentials = true;

xhr.addEventListener('readystatechange', function () {
  if (this.readyState === this.DONE) {
    console.log(this.responseText);
  }
});

xhr.open('POST', '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler');
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=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    InferenceSchedulerName: '',
    DataDelayOffsetInMinutes: '',
    DataUploadFrequency: '',
    DataInputConfiguration: '',
    DataOutputConfiguration: '',
    RoleArn: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"InferenceSchedulerName":"","DataDelayOffsetInMinutes":"","DataUploadFrequency":"","DataInputConfiguration":"","DataOutputConfiguration":"","RoleArn":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

const settings = {
  async: true,
  crossDomain: true,
  url: '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "InferenceSchedulerName": "",\n  "DataDelayOffsetInMinutes": "",\n  "DataUploadFrequency": "",\n  "DataInputConfiguration": "",\n  "DataOutputConfiguration": "",\n  "RoleArn": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler")
  .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({
  InferenceSchedulerName: '',
  DataDelayOffsetInMinutes: '',
  DataUploadFrequency: '',
  DataInputConfiguration: '',
  DataOutputConfiguration: '',
  RoleArn: ''
}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {
    InferenceSchedulerName: '',
    DataDelayOffsetInMinutes: '',
    DataUploadFrequency: '',
    DataInputConfiguration: '',
    DataOutputConfiguration: '',
    RoleArn: ''
  },
  json: true
};

request(options, function (error, response, body) {
  if (error) throw new Error(error);

  console.log(body);
});

const unirest = require('unirest');

const req = unirest('POST', '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  InferenceSchedulerName: '',
  DataDelayOffsetInMinutes: '',
  DataUploadFrequency: '',
  DataInputConfiguration: '',
  DataOutputConfiguration: '',
  RoleArn: ''
});

req.end(function (res) {
  if (res.error) throw new Error(res.error);

  console.log(res.body);
});

const axios = require('axios').default;

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {
    InferenceSchedulerName: '',
    DataDelayOffsetInMinutes: '',
    DataUploadFrequency: '',
    DataInputConfiguration: '',
    DataOutputConfiguration: '',
    RoleArn: ''
  }
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const fetch = require('node-fetch');

const url = '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"InferenceSchedulerName":"","DataDelayOffsetInMinutes":"","DataUploadFrequency":"","DataInputConfiguration":"","DataOutputConfiguration":"","RoleArn":""}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}

#import 

NSDictionary *headers = @{ @"x-amz-target": @"",
                           @"content-type": @"application/json" };
NSDictionary *parameters = @{ @"InferenceSchedulerName": @"",
                              @"DataDelayOffsetInMinutes": @"",
                              @"DataUploadFrequency": @"",
                              @"DataInputConfiguration": @"",
                              @"DataOutputConfiguration": @"",
                              @"RoleArn": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler"]
                                                       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=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler",
  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([
    'InferenceSchedulerName' => '',
    'DataDelayOffsetInMinutes' => '',
    'DataUploadFrequency' => '',
    'DataInputConfiguration' => '',
    'DataOutputConfiguration' => '',
    'RoleArn' => ''
  ]),
  CURLOPT_HTTPHEADER => [
    "content-type: application/json",
    "x-amz-target: "
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

request('POST', '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler', [
  'body' => '{
  "InferenceSchedulerName": "",
  "DataDelayOffsetInMinutes": "",
  "DataUploadFrequency": "",
  "DataInputConfiguration": "",
  "DataOutputConfiguration": "",
  "RoleArn": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'InferenceSchedulerName' => '',
  'DataDelayOffsetInMinutes' => '',
  'DataUploadFrequency' => '',
  'DataInputConfiguration' => '',
  'DataOutputConfiguration' => '',
  'RoleArn' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'InferenceSchedulerName' => '',
  'DataDelayOffsetInMinutes' => '',
  'DataUploadFrequency' => '',
  'DataInputConfiguration' => '',
  'DataOutputConfiguration' => '',
  'RoleArn' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler');
$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=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InferenceSchedulerName": "",
  "DataDelayOffsetInMinutes": "",
  "DataUploadFrequency": "",
  "DataInputConfiguration": "",
  "DataOutputConfiguration": "",
  "RoleArn": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "InferenceSchedulerName": "",
  "DataDelayOffsetInMinutes": "",
  "DataUploadFrequency": "",
  "DataInputConfiguration": "",
  "DataOutputConfiguration": "",
  "RoleArn": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\"\n}"

headers = {
    'x-amz-target': "",
    'content-type': "application/json"
}

conn.request("POST", "/baseUrl/", payload, headers)

res = conn.getresponse()
data = res.read()

print(data.decode("utf-8"))

import requests

url = "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler"

payload = {
    "InferenceSchedulerName": "",
    "DataDelayOffsetInMinutes": "",
    "DataUploadFrequency": "",
    "DataInputConfiguration": "",
    "DataOutputConfiguration": "",
    "RoleArn": ""
}
headers = {
    "x-amz-target": "",
    "content-type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

library(httr)

url <- "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler"

payload <- "{\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\"\n}"

encode <- "json"

response <- VERB("POST", url, body = payload, add_headers('x-amz-target' = ''), content_type("application/json"), encode = encode)

content(response, "text")

require 'uri'
require 'net/http'

url = URI("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler")

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  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\"\n}"

response = http.request(request)
puts response.read_body

require 'faraday'

conn = Faraday.new(
  url: 'https://example.com',
  headers: {'Content-Type' => 'application/json'}
)

response = conn.post('/baseUrl/') do |req|
  req.headers['x-amz-target'] = ''
  req.body = "{\n  \"InferenceSchedulerName\": \"\",\n  \"DataDelayOffsetInMinutes\": \"\",\n  \"DataUploadFrequency\": \"\",\n  \"DataInputConfiguration\": \"\",\n  \"DataOutputConfiguration\": \"\",\n  \"RoleArn\": \"\"\n}"
end

puts response.status
puts response.body

use serde_json::json;
use reqwest;

#[tokio::main]
pub async fn main() {
    let url = "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler";

    let payload = json!({
        "InferenceSchedulerName": "",
        "DataDelayOffsetInMinutes": "",
        "DataUploadFrequency": "",
        "DataInputConfiguration": "",
        "DataOutputConfiguration": "",
        "RoleArn": ""
    });

    let mut headers = reqwest::header::HeaderMap::new();
    headers.insert("x-amz-target", "".parse().unwrap());
    headers.insert("content-type", "application/json".parse().unwrap());

    let client = reqwest::Client::new();
    let response = client.post(url)
        .headers(headers)
        .json(&payload)
        .send()
        .await;

    let results = response.unwrap()
        .json::()
        .await
        .unwrap();

    dbg!(results);
}

curl --request POST \
  --url '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "InferenceSchedulerName": "",
  "DataDelayOffsetInMinutes": "",
  "DataUploadFrequency": "",
  "DataInputConfiguration": "",
  "DataOutputConfiguration": "",
  "RoleArn": ""
}'

echo '{
  "InferenceSchedulerName": "",
  "DataDelayOffsetInMinutes": "",
  "DataUploadFrequency": "",
  "DataInputConfiguration": "",
  "DataOutputConfiguration": "",
  "RoleArn": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "InferenceSchedulerName": "",\n  "DataDelayOffsetInMinutes": "",\n  "DataUploadFrequency": "",\n  "DataInputConfiguration": "",\n  "DataOutputConfiguration": "",\n  "RoleArn": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "InferenceSchedulerName": "",
  "DataDelayOffsetInMinutes": "",
  "DataUploadFrequency": "",
  "DataInputConfiguration": "",
  "DataOutputConfiguration": "",
  "RoleArn": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateInferenceScheduler")! 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 UpdateLabelGroup

{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateLabelGroup

HEADERS

X-Amz-Target

BODY json

{
  "LabelGroupName": "",
  "FaultCodes": ""
}

Examples

REQUEST

CURL *hnd = curl_easy_init();

curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateLabelGroup");

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  \"LabelGroupName\": \"\",\n  \"FaultCodes\": \"\"\n}");

CURLcode ret = curl_easy_perform(hnd);

(require '[clj-http.client :as client])

(client/post "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateLabelGroup" {:headers {:x-amz-target ""}
                                                                                                              :content-type :json
                                                                                                              :form-params {:LabelGroupName ""
                                                                                                                            :FaultCodes ""}})

require "http/client"

url = "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateLabelGroup"
headers = HTTP::Headers{
  "x-amz-target" => ""
  "content-type" => "application/json"
}
reqBody = "{\n  \"LabelGroupName\": \"\",\n  \"FaultCodes\": \"\"\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=AWSLookoutEquipmentFrontendService.UpdateLabelGroup"),
    Headers =
    {
        { "x-amz-target", "" },
    },
    Content = new StringContent("{\n  \"LabelGroupName\": \"\",\n  \"FaultCodes\": \"\"\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=AWSLookoutEquipmentFrontendService.UpdateLabelGroup");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
request.AddHeader("content-type", "application/json");
request.AddParameter("application/json", "{\n  \"LabelGroupName\": \"\",\n  \"FaultCodes\": \"\"\n}", ParameterType.RequestBody);
var response = client.Execute(request);

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateLabelGroup"

	payload := strings.NewReader("{\n  \"LabelGroupName\": \"\",\n  \"FaultCodes\": \"\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("x-amz-target", "")
	req.Header.Add("content-type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

POST /baseUrl/ HTTP/1.1
X-Amz-Target: 
Content-Type: application/json
Host: example.com
Content-Length: 46

{
  "LabelGroupName": "",
  "FaultCodes": ""
}

AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateLabelGroup")
  .setHeader("x-amz-target", "")
  .setHeader("content-type", "application/json")
  .setBody("{\n  \"LabelGroupName\": \"\",\n  \"FaultCodes\": \"\"\n}")
  .execute()
  .toCompletableFuture()
  .thenAccept(System.out::println)
  .join();

client.close();

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateLabelGroup"))
    .header("x-amz-target", "")
    .header("content-type", "application/json")
    .method("POST", HttpRequest.BodyPublishers.ofString("{\n  \"LabelGroupName\": \"\",\n  \"FaultCodes\": \"\"\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  \"LabelGroupName\": \"\",\n  \"FaultCodes\": \"\"\n}");
Request request = new Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateLabelGroup")
  .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=AWSLookoutEquipmentFrontendService.UpdateLabelGroup")
  .header("x-amz-target", "")
  .header("content-type", "application/json")
  .body("{\n  \"LabelGroupName\": \"\",\n  \"FaultCodes\": \"\"\n}")
  .asString();

const data = JSON.stringify({
  LabelGroupName: '',
  FaultCodes: ''
});

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=AWSLookoutEquipmentFrontendService.UpdateLabelGroup');
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=AWSLookoutEquipmentFrontendService.UpdateLabelGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {LabelGroupName: '', FaultCodes: ''}
};

try {
  const { data } = await axios.request(options);
  console.log(data);
} catch (error) {
  console.error(error);
}

const url = '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateLabelGroup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"LabelGroupName":"","FaultCodes":""}'
};

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=AWSLookoutEquipmentFrontendService.UpdateLabelGroup',
  method: 'POST',
  headers: {
    'x-amz-target': '',
    'content-type': 'application/json'
  },
  processData: false,
  data: '{\n  "LabelGroupName": "",\n  "FaultCodes": ""\n}'
};

$.ajax(settings).done(function (response) {
  console.log(response);
});

val client = OkHttpClient()

val mediaType = MediaType.parse("application/json")
val body = RequestBody.create(mediaType, "{\n  \"LabelGroupName\": \"\",\n  \"FaultCodes\": \"\"\n}")
val request = Request.Builder()
  .url("{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateLabelGroup")
  .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({LabelGroupName: '', FaultCodes: ''}));
req.end();

const request = require('request');

const options = {
  method: 'POST',
  url: '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateLabelGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: {LabelGroupName: '', FaultCodes: ''},
  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=AWSLookoutEquipmentFrontendService.UpdateLabelGroup');

req.headers({
  'x-amz-target': '',
  'content-type': 'application/json'
});

req.type('json');
req.send({
  LabelGroupName: '',
  FaultCodes: ''
});

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=AWSLookoutEquipmentFrontendService.UpdateLabelGroup',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  data: {LabelGroupName: '', FaultCodes: ''}
};

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=AWSLookoutEquipmentFrontendService.UpdateLabelGroup';
const options = {
  method: 'POST',
  headers: {'x-amz-target': '', 'content-type': 'application/json'},
  body: '{"LabelGroupName":"","FaultCodes":""}'
};

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 = @{ @"LabelGroupName": @"",
                              @"FaultCodes": @"" };

NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateLabelGroup"]
                                                       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=AWSLookoutEquipmentFrontendService.UpdateLabelGroup" in
let headers = Header.add_list (Header.init ()) [
  ("x-amz-target", "");
  ("content-type", "application/json");
] in
let body = Cohttp_lwt_body.of_string "{\n  \"LabelGroupName\": \"\",\n  \"FaultCodes\": \"\"\n}" in

Client.call ~headers ~body `POST uri
>>= fun (res, body_stream) ->
  (* Do stuff with the result *)

 "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateLabelGroup",
  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([
    'LabelGroupName' => '',
    'FaultCodes' => ''
  ]),
  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=AWSLookoutEquipmentFrontendService.UpdateLabelGroup', [
  'body' => '{
  "LabelGroupName": "",
  "FaultCodes": ""
}',
  'headers' => [
    'content-type' => 'application/json',
    'x-amz-target' => '',
  ],
]);

echo $response->getBody();

setUrl('{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateLabelGroup');
$request->setMethod(HTTP_METH_POST);

$request->setHeaders([
  'x-amz-target' => '',
  'content-type' => 'application/json'
]);

$request->setContentType('application/json');
$request->setBody(json_encode([
  'LabelGroupName' => '',
  'FaultCodes' => ''
]));

try {
  $response = $request->send();

  echo $response->getBody();
} catch (HttpException $ex) {
  echo $ex;
}

append(json_encode([
  'LabelGroupName' => '',
  'FaultCodes' => ''
]));
$request->setRequestUrl('{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateLabelGroup');
$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=AWSLookoutEquipmentFrontendService.UpdateLabelGroup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "LabelGroupName": "",
  "FaultCodes": ""
}'

$headers=@{}
$headers.Add("x-amz-target", "")
$headers.Add("content-type", "application/json")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateLabelGroup' -Method POST -Headers $headers -ContentType 'application/json' -Body '{
  "LabelGroupName": "",
  "FaultCodes": ""
}'

import http.client

conn = http.client.HTTPSConnection("example.com")

payload = "{\n  \"LabelGroupName\": \"\",\n  \"FaultCodes\": \"\"\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=AWSLookoutEquipmentFrontendService.UpdateLabelGroup"

payload = {
    "LabelGroupName": "",
    "FaultCodes": ""
}
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=AWSLookoutEquipmentFrontendService.UpdateLabelGroup"

payload <- "{\n  \"LabelGroupName\": \"\",\n  \"FaultCodes\": \"\"\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=AWSLookoutEquipmentFrontendService.UpdateLabelGroup")

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  \"LabelGroupName\": \"\",\n  \"FaultCodes\": \"\"\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  \"LabelGroupName\": \"\",\n  \"FaultCodes\": \"\"\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=AWSLookoutEquipmentFrontendService.UpdateLabelGroup";

    let payload = json!({
        "LabelGroupName": "",
        "FaultCodes": ""
    });

    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=AWSLookoutEquipmentFrontendService.UpdateLabelGroup' \
  --header 'content-type: application/json' \
  --header 'x-amz-target: ' \
  --data '{
  "LabelGroupName": "",
  "FaultCodes": ""
}'

echo '{
  "LabelGroupName": "",
  "FaultCodes": ""
}' |  \
  http POST '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateLabelGroup' \
  content-type:application/json \
  x-amz-target:''

wget --quiet \
  --method POST \
  --header 'x-amz-target: ' \
  --header 'content-type: application/json' \
  --body-data '{\n  "LabelGroupName": "",\n  "FaultCodes": ""\n}' \
  --output-document \
  - '{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateLabelGroup'

import Foundation

let headers = [
  "x-amz-target": "",
  "content-type": "application/json"
]
let parameters = [
  "LabelGroupName": "",
  "FaultCodes": ""
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=AWSLookoutEquipmentFrontendService.UpdateLabelGroup")! 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()