Amazon Inspector
POST
AddAttributesToFindings
{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.AddAttributesToFindings");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.AddAttributesToFindings');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.AddAttributesToFindings',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings',
headers: {'x-amz-target': ''}
};
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=InspectorService.AddAttributesToFindings');
req.headers({
'x-amz-target': ''
});
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=InspectorService.AddAttributesToFindings',
headers: {'x-amz-target': ''}
};
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=InspectorService.AddAttributesToFindings';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.AddAttributesToFindings" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.AddAttributesToFindings', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.AddAttributesToFindings")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
CreateAssessmentTarget
{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.CreateAssessmentTarget");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.CreateAssessmentTarget');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.CreateAssessmentTarget',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget',
headers: {'x-amz-target': ''}
};
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=InspectorService.CreateAssessmentTarget');
req.headers({
'x-amz-target': ''
});
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=InspectorService.CreateAssessmentTarget',
headers: {'x-amz-target': ''}
};
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=InspectorService.CreateAssessmentTarget';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.CreateAssessmentTarget" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.CreateAssessmentTarget', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTarget")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
CreateAssessmentTemplate
{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.CreateAssessmentTemplate");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.CreateAssessmentTemplate');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.CreateAssessmentTemplate',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate',
headers: {'x-amz-target': ''}
};
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=InspectorService.CreateAssessmentTemplate');
req.headers({
'x-amz-target': ''
});
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=InspectorService.CreateAssessmentTemplate',
headers: {'x-amz-target': ''}
};
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=InspectorService.CreateAssessmentTemplate';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.CreateAssessmentTemplate" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.CreateAssessmentTemplate', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateAssessmentTemplate")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
CreateExclusionsPreview
{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.CreateExclusionsPreview");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.CreateExclusionsPreview');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.CreateExclusionsPreview',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview',
headers: {'x-amz-target': ''}
};
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=InspectorService.CreateExclusionsPreview');
req.headers({
'x-amz-target': ''
});
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=InspectorService.CreateExclusionsPreview',
headers: {'x-amz-target': ''}
};
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=InspectorService.CreateExclusionsPreview';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.CreateExclusionsPreview" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.CreateExclusionsPreview', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateExclusionsPreview")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
CreateResourceGroup
{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.CreateResourceGroup");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.CreateResourceGroup');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.CreateResourceGroup',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup',
headers: {'x-amz-target': ''}
};
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=InspectorService.CreateResourceGroup');
req.headers({
'x-amz-target': ''
});
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=InspectorService.CreateResourceGroup',
headers: {'x-amz-target': ''}
};
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=InspectorService.CreateResourceGroup';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.CreateResourceGroup" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.CreateResourceGroup', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.CreateResourceGroup")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
DeleteAssessmentRun
{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.DeleteAssessmentRun");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.DeleteAssessmentRun');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.DeleteAssessmentRun',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun',
headers: {'x-amz-target': ''}
};
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=InspectorService.DeleteAssessmentRun');
req.headers({
'x-amz-target': ''
});
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=InspectorService.DeleteAssessmentRun',
headers: {'x-amz-target': ''}
};
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=InspectorService.DeleteAssessmentRun';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.DeleteAssessmentRun" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.DeleteAssessmentRun', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentRun")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
DeleteAssessmentTarget
{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.DeleteAssessmentTarget");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.DeleteAssessmentTarget');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.DeleteAssessmentTarget',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget',
headers: {'x-amz-target': ''}
};
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=InspectorService.DeleteAssessmentTarget');
req.headers({
'x-amz-target': ''
});
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=InspectorService.DeleteAssessmentTarget',
headers: {'x-amz-target': ''}
};
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=InspectorService.DeleteAssessmentTarget';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.DeleteAssessmentTarget" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.DeleteAssessmentTarget', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTarget")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
DeleteAssessmentTemplate
{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.DeleteAssessmentTemplate");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.DeleteAssessmentTemplate');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.DeleteAssessmentTemplate',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate',
headers: {'x-amz-target': ''}
};
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=InspectorService.DeleteAssessmentTemplate');
req.headers({
'x-amz-target': ''
});
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=InspectorService.DeleteAssessmentTemplate',
headers: {'x-amz-target': ''}
};
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=InspectorService.DeleteAssessmentTemplate';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.DeleteAssessmentTemplate" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.DeleteAssessmentTemplate', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.DeleteAssessmentTemplate")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
DescribeAssessmentRuns
{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.DescribeAssessmentRuns");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.DescribeAssessmentRuns');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.DescribeAssessmentRuns',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns',
headers: {'x-amz-target': ''}
};
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=InspectorService.DescribeAssessmentRuns');
req.headers({
'x-amz-target': ''
});
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=InspectorService.DescribeAssessmentRuns',
headers: {'x-amz-target': ''}
};
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=InspectorService.DescribeAssessmentRuns';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.DescribeAssessmentRuns" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.DescribeAssessmentRuns', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentRuns")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
DescribeAssessmentTargets
{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.DescribeAssessmentTargets");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.DescribeAssessmentTargets');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.DescribeAssessmentTargets',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets',
headers: {'x-amz-target': ''}
};
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=InspectorService.DescribeAssessmentTargets');
req.headers({
'x-amz-target': ''
});
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=InspectorService.DescribeAssessmentTargets',
headers: {'x-amz-target': ''}
};
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=InspectorService.DescribeAssessmentTargets';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.DescribeAssessmentTargets" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.DescribeAssessmentTargets', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTargets")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
DescribeAssessmentTemplates
{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.DescribeAssessmentTemplates");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.DescribeAssessmentTemplates');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.DescribeAssessmentTemplates',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates',
headers: {'x-amz-target': ''}
};
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=InspectorService.DescribeAssessmentTemplates');
req.headers({
'x-amz-target': ''
});
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=InspectorService.DescribeAssessmentTemplates',
headers: {'x-amz-target': ''}
};
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=InspectorService.DescribeAssessmentTemplates';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.DescribeAssessmentTemplates" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.DescribeAssessmentTemplates', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeAssessmentTemplates")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
DescribeCrossAccountAccessRole
{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.DescribeCrossAccountAccessRole");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.DescribeCrossAccountAccessRole');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.DescribeCrossAccountAccessRole',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole',
headers: {'x-amz-target': ''}
};
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=InspectorService.DescribeCrossAccountAccessRole');
req.headers({
'x-amz-target': ''
});
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=InspectorService.DescribeCrossAccountAccessRole',
headers: {'x-amz-target': ''}
};
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=InspectorService.DescribeCrossAccountAccessRole';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.DescribeCrossAccountAccessRole" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.DescribeCrossAccountAccessRole', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeCrossAccountAccessRole")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
DescribeExclusions
{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.DescribeExclusions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.DescribeExclusions');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.DescribeExclusions',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions',
headers: {'x-amz-target': ''}
};
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=InspectorService.DescribeExclusions');
req.headers({
'x-amz-target': ''
});
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=InspectorService.DescribeExclusions',
headers: {'x-amz-target': ''}
};
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=InspectorService.DescribeExclusions';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.DescribeExclusions" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.DescribeExclusions', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeExclusions")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
DescribeFindings
{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.DescribeFindings");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.DescribeFindings');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.DescribeFindings',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings',
headers: {'x-amz-target': ''}
};
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=InspectorService.DescribeFindings');
req.headers({
'x-amz-target': ''
});
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=InspectorService.DescribeFindings',
headers: {'x-amz-target': ''}
};
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=InspectorService.DescribeFindings';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.DescribeFindings" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.DescribeFindings', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeFindings")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
DescribeResourceGroups
{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.DescribeResourceGroups");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.DescribeResourceGroups');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.DescribeResourceGroups',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups',
headers: {'x-amz-target': ''}
};
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=InspectorService.DescribeResourceGroups');
req.headers({
'x-amz-target': ''
});
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=InspectorService.DescribeResourceGroups',
headers: {'x-amz-target': ''}
};
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=InspectorService.DescribeResourceGroups';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.DescribeResourceGroups" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.DescribeResourceGroups', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeResourceGroups")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
DescribeRulesPackages
{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.DescribeRulesPackages");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.DescribeRulesPackages');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.DescribeRulesPackages',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages',
headers: {'x-amz-target': ''}
};
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=InspectorService.DescribeRulesPackages');
req.headers({
'x-amz-target': ''
});
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=InspectorService.DescribeRulesPackages',
headers: {'x-amz-target': ''}
};
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=InspectorService.DescribeRulesPackages';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.DescribeRulesPackages" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.DescribeRulesPackages', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.DescribeRulesPackages")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
GetAssessmentReport
{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.GetAssessmentReport");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.GetAssessmentReport');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.GetAssessmentReport',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport',
headers: {'x-amz-target': ''}
};
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=InspectorService.GetAssessmentReport');
req.headers({
'x-amz-target': ''
});
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=InspectorService.GetAssessmentReport',
headers: {'x-amz-target': ''}
};
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=InspectorService.GetAssessmentReport';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.GetAssessmentReport" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.GetAssessmentReport', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.GetAssessmentReport")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
GetExclusionsPreview
{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.GetExclusionsPreview");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.GetExclusionsPreview');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.GetExclusionsPreview',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview',
headers: {'x-amz-target': ''}
};
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=InspectorService.GetExclusionsPreview');
req.headers({
'x-amz-target': ''
});
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=InspectorService.GetExclusionsPreview',
headers: {'x-amz-target': ''}
};
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=InspectorService.GetExclusionsPreview';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.GetExclusionsPreview" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.GetExclusionsPreview', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.GetExclusionsPreview")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
GetTelemetryMetadata
{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.GetTelemetryMetadata");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.GetTelemetryMetadata');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.GetTelemetryMetadata',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata',
headers: {'x-amz-target': ''}
};
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=InspectorService.GetTelemetryMetadata');
req.headers({
'x-amz-target': ''
});
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=InspectorService.GetTelemetryMetadata',
headers: {'x-amz-target': ''}
};
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=InspectorService.GetTelemetryMetadata';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.GetTelemetryMetadata" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.GetTelemetryMetadata', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.GetTelemetryMetadata")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
ListAssessmentRunAgents
{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.ListAssessmentRunAgents");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.ListAssessmentRunAgents');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.ListAssessmentRunAgents',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents',
headers: {'x-amz-target': ''}
};
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=InspectorService.ListAssessmentRunAgents');
req.headers({
'x-amz-target': ''
});
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=InspectorService.ListAssessmentRunAgents',
headers: {'x-amz-target': ''}
};
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=InspectorService.ListAssessmentRunAgents';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.ListAssessmentRunAgents" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.ListAssessmentRunAgents', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRunAgents")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
ListAssessmentRuns
{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.ListAssessmentRuns");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.ListAssessmentRuns');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.ListAssessmentRuns',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns',
headers: {'x-amz-target': ''}
};
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=InspectorService.ListAssessmentRuns');
req.headers({
'x-amz-target': ''
});
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=InspectorService.ListAssessmentRuns',
headers: {'x-amz-target': ''}
};
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=InspectorService.ListAssessmentRuns';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.ListAssessmentRuns" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.ListAssessmentRuns', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentRuns")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
ListAssessmentTargets
{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.ListAssessmentTargets");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.ListAssessmentTargets');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.ListAssessmentTargets',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets',
headers: {'x-amz-target': ''}
};
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=InspectorService.ListAssessmentTargets');
req.headers({
'x-amz-target': ''
});
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=InspectorService.ListAssessmentTargets',
headers: {'x-amz-target': ''}
};
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=InspectorService.ListAssessmentTargets';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.ListAssessmentTargets" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.ListAssessmentTargets', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTargets")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
ListAssessmentTemplates
{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.ListAssessmentTemplates");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.ListAssessmentTemplates');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.ListAssessmentTemplates',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates',
headers: {'x-amz-target': ''}
};
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=InspectorService.ListAssessmentTemplates');
req.headers({
'x-amz-target': ''
});
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=InspectorService.ListAssessmentTemplates',
headers: {'x-amz-target': ''}
};
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=InspectorService.ListAssessmentTemplates';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.ListAssessmentTemplates" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.ListAssessmentTemplates', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.ListAssessmentTemplates")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
ListEventSubscriptions
{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.ListEventSubscriptions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.ListEventSubscriptions');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.ListEventSubscriptions',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions',
headers: {'x-amz-target': ''}
};
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=InspectorService.ListEventSubscriptions');
req.headers({
'x-amz-target': ''
});
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=InspectorService.ListEventSubscriptions',
headers: {'x-amz-target': ''}
};
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=InspectorService.ListEventSubscriptions';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.ListEventSubscriptions" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.ListEventSubscriptions', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.ListEventSubscriptions")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
ListExclusions
{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.ListExclusions");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.ListExclusions');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.ListExclusions',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions',
headers: {'x-amz-target': ''}
};
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=InspectorService.ListExclusions');
req.headers({
'x-amz-target': ''
});
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=InspectorService.ListExclusions',
headers: {'x-amz-target': ''}
};
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=InspectorService.ListExclusions';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.ListExclusions" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.ListExclusions', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.ListExclusions")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
ListFindings
{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.ListFindings");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.ListFindings');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.ListFindings',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings',
headers: {'x-amz-target': ''}
};
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=InspectorService.ListFindings');
req.headers({
'x-amz-target': ''
});
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=InspectorService.ListFindings',
headers: {'x-amz-target': ''}
};
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=InspectorService.ListFindings';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.ListFindings" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.ListFindings', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.ListFindings")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
ListRulesPackages
{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.ListRulesPackages");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.ListRulesPackages');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.ListRulesPackages',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages',
headers: {'x-amz-target': ''}
};
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=InspectorService.ListRulesPackages');
req.headers({
'x-amz-target': ''
});
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=InspectorService.ListRulesPackages',
headers: {'x-amz-target': ''}
};
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=InspectorService.ListRulesPackages';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.ListRulesPackages" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.ListRulesPackages', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.ListRulesPackages")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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=InspectorService.ListTagsForResource
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.ListTagsForResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.ListTagsForResource');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.ListTagsForResource',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource',
headers: {'x-amz-target': ''}
};
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=InspectorService.ListTagsForResource');
req.headers({
'x-amz-target': ''
});
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=InspectorService.ListTagsForResource',
headers: {'x-amz-target': ''}
};
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=InspectorService.ListTagsForResource';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.ListTagsForResource" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.ListTagsForResource', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.ListTagsForResource")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
PreviewAgents
{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.PreviewAgents");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.PreviewAgents');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.PreviewAgents',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents',
headers: {'x-amz-target': ''}
};
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=InspectorService.PreviewAgents');
req.headers({
'x-amz-target': ''
});
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=InspectorService.PreviewAgents',
headers: {'x-amz-target': ''}
};
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=InspectorService.PreviewAgents';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.PreviewAgents" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.PreviewAgents', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.PreviewAgents")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
RegisterCrossAccountAccessRole
{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.RegisterCrossAccountAccessRole");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.RegisterCrossAccountAccessRole');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.RegisterCrossAccountAccessRole',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole',
headers: {'x-amz-target': ''}
};
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=InspectorService.RegisterCrossAccountAccessRole');
req.headers({
'x-amz-target': ''
});
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=InspectorService.RegisterCrossAccountAccessRole',
headers: {'x-amz-target': ''}
};
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=InspectorService.RegisterCrossAccountAccessRole';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.RegisterCrossAccountAccessRole" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.RegisterCrossAccountAccessRole', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.RegisterCrossAccountAccessRole")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
RemoveAttributesFromFindings
{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.RemoveAttributesFromFindings");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.RemoveAttributesFromFindings');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.RemoveAttributesFromFindings',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings',
headers: {'x-amz-target': ''}
};
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=InspectorService.RemoveAttributesFromFindings');
req.headers({
'x-amz-target': ''
});
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=InspectorService.RemoveAttributesFromFindings',
headers: {'x-amz-target': ''}
};
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=InspectorService.RemoveAttributesFromFindings';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.RemoveAttributesFromFindings" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.RemoveAttributesFromFindings', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.RemoveAttributesFromFindings")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
SetTagsForResource
{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.SetTagsForResource");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.SetTagsForResource');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.SetTagsForResource',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource',
headers: {'x-amz-target': ''}
};
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=InspectorService.SetTagsForResource');
req.headers({
'x-amz-target': ''
});
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=InspectorService.SetTagsForResource',
headers: {'x-amz-target': ''}
};
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=InspectorService.SetTagsForResource';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.SetTagsForResource" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.SetTagsForResource', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.SetTagsForResource")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
StartAssessmentRun
{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.StartAssessmentRun");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.StartAssessmentRun');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.StartAssessmentRun',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun',
headers: {'x-amz-target': ''}
};
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=InspectorService.StartAssessmentRun');
req.headers({
'x-amz-target': ''
});
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=InspectorService.StartAssessmentRun',
headers: {'x-amz-target': ''}
};
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=InspectorService.StartAssessmentRun';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.StartAssessmentRun" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.StartAssessmentRun', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.StartAssessmentRun")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
StopAssessmentRun
{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.StopAssessmentRun");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.StopAssessmentRun');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.StopAssessmentRun',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun',
headers: {'x-amz-target': ''}
};
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=InspectorService.StopAssessmentRun');
req.headers({
'x-amz-target': ''
});
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=InspectorService.StopAssessmentRun',
headers: {'x-amz-target': ''}
};
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=InspectorService.StopAssessmentRun';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.StopAssessmentRun" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.StopAssessmentRun', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.StopAssessmentRun")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
SubscribeToEvent
{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.SubscribeToEvent");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.SubscribeToEvent');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.SubscribeToEvent',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent',
headers: {'x-amz-target': ''}
};
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=InspectorService.SubscribeToEvent');
req.headers({
'x-amz-target': ''
});
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=InspectorService.SubscribeToEvent',
headers: {'x-amz-target': ''}
};
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=InspectorService.SubscribeToEvent';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.SubscribeToEvent" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.SubscribeToEvent', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.SubscribeToEvent")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
UnsubscribeFromEvent
{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.UnsubscribeFromEvent");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.UnsubscribeFromEvent');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.UnsubscribeFromEvent',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent',
headers: {'x-amz-target': ''}
};
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=InspectorService.UnsubscribeFromEvent');
req.headers({
'x-amz-target': ''
});
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=InspectorService.UnsubscribeFromEvent',
headers: {'x-amz-target': ''}
};
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=InspectorService.UnsubscribeFromEvent';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.UnsubscribeFromEvent" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.UnsubscribeFromEvent', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.UnsubscribeFromEvent")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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
UpdateAssessmentTarget
{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget
HEADERS
X-Amz-Target
Examples
REQUEST
CURL *hnd = curl_easy_init();
curl_easy_setopt(hnd, CURLOPT_CUSTOMREQUEST, "POST");
curl_easy_setopt(hnd, CURLOPT_URL, "{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget");
struct curl_slist *headers = NULL;
headers = curl_slist_append(headers, "x-amz-target: ");
curl_easy_setopt(hnd, CURLOPT_HTTPHEADER, headers);
CURLcode ret = curl_easy_perform(hnd);(require '[clj-http.client :as client])
(client/post "{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget" {:headers {:x-amz-target ""}})require "http/client"
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget"
headers = HTTP::Headers{
"x-amz-target" => ""
}
response = HTTP::Client.post url, headers: headers
puts response.bodyusing System.Net.Http.Headers;
var client = new HttpClient();
var request = new HttpRequestMessage
{
Method = HttpMethod.Post,
RequestUri = new Uri("{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget"),
Headers =
{
{ "x-amz-target", "" },
},
};
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=InspectorService.UpdateAssessmentTarget");
var request = new RestRequest("", Method.Post);
request.AddHeader("x-amz-target", "");
var response = client.Execute(request);package main
import (
"fmt"
"net/http"
"io"
)
func main() {
url := "{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget"
req, _ := http.NewRequest("POST", url, nil)
req.Header.Add("x-amz-target", "")
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:
Host: example.com
AsyncHttpClient client = new DefaultAsyncHttpClient();
client.prepare("POST", "{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget")
.setHeader("x-amz-target", "")
.execute()
.toCompletableFuture()
.thenAccept(System.out::println)
.join();
client.close();HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create("{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget"))
.header("x-amz-target", "")
.method("POST", HttpRequest.BodyPublishers.noBody())
.build();
HttpResponse response = HttpClient.newHttpClient().send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body()); OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget")
.post(null)
.addHeader("x-amz-target", "")
.build();
Response response = client.newCall(request).execute();HttpResponse response = Unirest.post("{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget")
.header("x-amz-target", "")
.asString(); const data = null;
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=InspectorService.UpdateAssessmentTarget');
xhr.setRequestHeader('x-amz-target', '');
xhr.send(data);import axios from 'axios';
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget',
headers: {'x-amz-target': ''}
};
try {
const { data } = await axios.request(options);
console.log(data);
} catch (error) {
console.error(error);
}const url = '{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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=InspectorService.UpdateAssessmentTarget',
method: 'POST',
headers: {
'x-amz-target': ''
}
};
$.ajax(settings).done(function (response) {
console.log(response);
});val client = OkHttpClient()
val request = Request.Builder()
.url("{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget")
.post(null)
.addHeader("x-amz-target", "")
.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': ''
}
};
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.end();const request = require('request');
const options = {
method: 'POST',
url: '{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget',
headers: {'x-amz-target': ''}
};
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=InspectorService.UpdateAssessmentTarget');
req.headers({
'x-amz-target': ''
});
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=InspectorService.UpdateAssessmentTarget',
headers: {'x-amz-target': ''}
};
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=InspectorService.UpdateAssessmentTarget';
const options = {method: 'POST', headers: {'x-amz-target': ''}};
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": @"" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"POST"];
[request setAllHTTPHeaderFields:headers];
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=InspectorService.UpdateAssessmentTarget" in
let headers = Header.add (Header.init ()) "x-amz-target" "" in
Client.call ~headers `POST uri
>>= fun (res, body_stream) ->
(* Do stuff with the result *) "{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "POST",
CURLOPT_HTTPHEADER => [
"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=InspectorService.UpdateAssessmentTarget', [
'headers' => [
'x-amz-target' => '',
],
]);
echo $response->getBody();setUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget');
$request->setMethod(HTTP_METH_POST);
$request->setHeaders([
'x-amz-target' => ''
]);
try {
$response = $request->send();
echo $response->getBody();
} catch (HttpException $ex) {
echo $ex;
}setRequestUrl('{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget');
$request->setRequestMethod('POST');
$request->setHeaders([
'x-amz-target' => ''
]);
$client->enqueue($request)->send();
$response = $client->getResponse();
echo $response->getBody();$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-WebRequest -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget' -Method POST -Headers $headers$headers=@{}
$headers.Add("x-amz-target", "")
$response = Invoke-RestMethod -Uri '{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget' -Method POST -Headers $headersimport http.client
conn = http.client.HTTPSConnection("example.com")
headers = { 'x-amz-target': "" }
conn.request("POST", "/baseUrl/", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))import requests
url = "{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget"
headers = {"x-amz-target": ""}
response = requests.post(url, headers=headers)
print(response.json())library(httr)
url <- "{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget"
response <- VERB("POST", url, add_headers('x-amz-target' = ''), content_type("application/octet-stream"))
content(response, "text")require 'uri'
require 'net/http'
url = URI("{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
request = Net::HTTP::Post.new(url)
request["x-amz-target"] = ''
response = http.request(request)
puts response.read_bodyrequire 'faraday'
conn = Faraday.new(
url: 'https://example.com',
)
response = conn.post('/baseUrl/') do |req|
req.headers['x-amz-target'] = ''
end
puts response.status
puts response.bodyuse reqwest;
#[tokio::main]
pub async fn main() {
let url = "{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget";
let mut headers = reqwest::header::HeaderMap::new();
headers.insert("x-amz-target", "".parse().unwrap());
let client = reqwest::Client::new();
let response = client.post(url)
.headers(headers)
.send()
.await;
let results = response.unwrap()
.json::()
.await
.unwrap();
dbg!(results);
}
curl --request POST \
--url '{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget' \
--header 'x-amz-target: 'http POST '{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget' \
x-amz-target:''wget --quiet \
--method POST \
--header 'x-amz-target: ' \
--output-document \
- '{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget'import Foundation
let headers = ["x-amz-target": ""]
let request = NSMutableURLRequest(url: NSURL(string: "{{baseUrl}}/#X-Amz-Target=InspectorService.UpdateAssessmentTarget")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
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()